C:/Programs/source/NIREP/NIREPDefinitions/NIREPDefinitions.h

#pragma once
#ifndef _NIREP_DEFINITIONS_H_
#define _NIREP_DEFINITIONS_H_

//Purpose: Have one file that is full of the definitions throughout NIREP.  Most of the
//definitions will be the commands that users will be using to create displays and load in
//data.  There are some definitions about the input and output of some of the commands and
//other items deemed necessary.  Most items in this file are of the type map.


#include <vector>
#include <string>
#include <map>
#include <algorithm>

// All widget commands are lower case for case insensitive string comparison
// Only make changes to the values of this map since the indexes are fixed
// in the rest of the program.  That is to change the widget command in the
// display description from "checkerboard" to "cb" you would change
// m["checkerboard"] = "checkerboard"; to m["checkerboard"] = "cb";
// The case of the keys do not affect the lowercase comparison and need
// to stay the same as they are here since they are hardcoded throughout
// the program.
typedef std::map<std::string, std::string> WidgetCmdList;
static WidgetCmdList create_widget_cmd_map(){
  WidgetCmdList m;
  m["view"]                         = "view"; // 2 inputs: image, title
  m["checkerboard"]                 = "checkerboard"; // 3 inputs: image1, image2, title
  m["wipe"]                         = "wipe"; // 3 inputs: image1, image2, title
  m["objectmap"]                    = "objectmap"; // 2 inputs: objmap, title
  m["overlayObjectMap"]             = "overlayobjectmap"; // 3 inputs: image, objmap, title
  m["overlayImage"]                 = "overlayimage"; // 3 inputs: image1, image2, title
  m["relativeOverlap"]              = "relativeoverlap"; // 3 inputs: objmap1, objmap2, title
  m["relativeOverlapTextWidget"]    = "relativeoverlaptextwidget"; // 3 inputs: objmap1, objmap2, title
  //m["intensityVarianceTextWidget"]  = "intensityvariancetextwidget"; // OBSOLETE
  m["inverseConsistencyTextWidget"] = "inverseconsistencytextwidget"; // 3 inputs: iceimg, objmap, title
  m["transitivityErrorTextWidget"]  = "transitivityerrortextwidget"; // 3 inputs: teimg, objmap, title
  m["varianceTransformText"]        = "variancetransformtext"; // 5 inputs: refimg, images, label, algo, title
  m["varianceImageText"]            = "varianceimagetext"; // 3 inputs: images, label, title
  m["text"]                         = "text"; // 2 inputs: text_table, title
  m["blankWidget"]                  = "blankwidget";
  m["vectorField"]                  = "vectorfield";
  m["grid"]                         = "grid";
  return m;
}

static WidgetCmdList WidgetCmd = create_widget_cmd_map();

typedef std::map<std::string, std::string> InputTypeList;
static InputTypeList create_input_types_map(){
  InputTypeList m;
  m["Cs_id"]                = "cs_id";
  m["Label"]                = "label";
  m["Algorithm"]            = "algorithm";
  m["Image"]                = "image";
  m["Images"]               = "images";
  m["Transformation"]       = "transformation";
  m["Interpolation"]        = "interpolation";
  m["Method"]               = "method";
  m["Title"]                = "title";
  m["Objectmap"]            = "objectmap";
  m["ICE"]                  = "inverse consistency error image";
  m["TE"]                   = "transitivity error image";
  m["TextTable"]            = "text table";
  
  return m;
}

static InputTypeList InputType = create_input_types_map();



typedef std::multimap<std::string, std::string> WidgetInputList;
static WidgetInputList create_widget_input_map(){
  WidgetInputList m;
  //m["view"]                         = "(image, title)"; // 2 inputs: image, title
  m.insert(std::pair<std::string, std::string>(WidgetCmd["view"],InputType["Image"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["view"],InputType["Title"]));

  //m["checkerboard"]                 = "(image1,image2,title)"; // 3 inputs: image1, image2, title
  m.insert(std::pair<std::string, std::string>(WidgetCmd["checkerboard"],InputType["Image"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["checkerboard"],InputType["Image"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["checkerboard"],InputType["Title"]));

  //m["wipe"]                         = "(image1,image2,title)"; // 3 inputs: image1, image2, title
  m.insert(std::pair<std::string, std::string>(WidgetCmd["wipe"],InputType["Image"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["wipe"],InputType["Image"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["wipe"],InputType["Title"]));

  //m["objectmap"]                    = "(objectmap,title)"; // 2 inputs: objmap, title
  m.insert(std::pair<std::string, std::string>(WidgetCmd["objectmap"],InputType["Objectmap"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["objectmap"],InputType["Title"]));

  //m["overlayObjectMap"]             = "(image,objectmap,title)"; // 3 inputs: image, objmap, title
  m.insert(std::pair<std::string, std::string>(WidgetCmd["overlayObjectMap"],InputType["Image"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["overlayObjectMap"],InputType["Objectmap"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["overlayObjectMap"],InputType["Title"]));

  //m["overlayImage"]                 = "(image1,image2,title)"; // 3 inputs: image1, image2, title
  m.insert(std::pair<std::string, std::string>(WidgetCmd["overlayImage"],InputType["Image"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["overlayImage"],InputType["Image"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["overlayImage"],InputType["Title"]));

  //m["relativeOverlap"]              = "(objectmap1,objectmap2,title)"; // 3 inputs: objmap1, objmap2, title
  m.insert(std::pair<std::string, std::string>(WidgetCmd["relativeOverlap"],InputType["Objectmap"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["relativeOverlap"],InputType["Objectmap"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["relativeOverlap"],InputType["Title"]));

  //m["relativeOverlapTextWidget"]    = "(objectmap1,objectmap2,title)"; // 3 inputs: objmap1, objmap2, title
  m.insert(std::pair<std::string, std::string>(WidgetCmd["relativeOverlapTextWidget"],InputType["Objectmap"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["relativeOverlapTextWidget"],InputType["Objectmap"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["relativeOverlapTextWidget"],InputType["Title"]));

  //m["inverseConsistencyTextWidget"] = "(inverse consistency error image,objectmap,title)"; // 3 inputs: iceimg, objmap, title
  m.insert(std::pair<std::string, std::string>(WidgetCmd["inverseConsistencyTextWidget"],InputType["ICE"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["inverseConsistencyTextWidget"],InputType["Objectmap"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["inverseConsistencyTextWidget"],InputType["Title"]));

  //m["transitivityErrorTextWidget"]  = "(transitivity error image,objectmap image,title)"; // 3 inputs: teimg, objmap, title
  m.insert(std::pair<std::string, std::string>(WidgetCmd["transitivityErrorTextWidget"],InputType["TE"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["transitivityErrorTextWidget"],InputType["Objectmap"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["transitivityErrorTextWidget"],InputType["Title"]));


  //m["varianceTransformText"]        = "(reference image, images, label, algorithm, title)"; // 5 inputs: refimg, images, label, algo, title
  m.insert(std::pair<std::string, std::string>(WidgetCmd["varianceTransformText"],InputType["Image"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["varianceTransformText"],InputType["Images"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["varianceTransformText"],InputType["Algorithm"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["varianceTransformText"],InputType["Title"]));


  //m["varianceImageText"]            = "(images, label, title)"; // 3 inputs: images, label, title
  m.insert(std::pair<std::string, std::string>(WidgetCmd["varianceImageText"],InputType["Images"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["varianceImageText"],InputType["Label"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["varianceImageText"],InputType["Title"]));

  //m["text"]                         = "(text_table, title)"; // 2 inputs: text_table, title
  m.insert(std::pair<std::string, std::string>(WidgetCmd["text"],InputType["TextTable"]));
  m.insert(std::pair<std::string, std::string>(WidgetCmd["text"],InputType["Title"]));
  return m;
}

static WidgetInputList WidgetInput = create_widget_input_map();

//static struct DisplayAttributeCommands {
//  std::vector<std::string> commands;
//
//  DisplayAttributeCommands() {
//    commands.push_back("rowSize");
//    commands.push_back("columnSize");
//    commands.push_back("Lock");
//    commands.push_back("CursorLocation");
//    commands.push_back("Slice");
//    commands.push_back("Orientation");
//    commands.push_back("LockAll");
//  };
//}displayAttributeCommands;

//use global variables
//Display commands
//static struct DisplayAttributeCommands {
//  std::vector<std::string> commands;
//
//  DisplayAttributeCommands() {
//    commands.push_back("rowsize");
//    commands.push_back("columnsize");
//    commands.push_back("lock");
//    commands.push_back("cursorlocation");
//    commands.push_back("slice");
//    commands.push_back("orientation");
//    commands.push_back("lockall");
//  };
//}displayAttributeCommands;

typedef std::map<std::string, std::string> DisplayAttributeCmdList;
static DisplayAttributeCmdList create_display_attribute_cmd_map(){
  DisplayAttributeCmdList m;
  m["Rowsize"]           = "rowsize";
  m["Columnsize"]        = "columnsize";
  m["Lock"]              = "lock";
  m["Cursorlocation"]    = "cursorlocation";
  m["Slice"]             = "slice";
  m["Orientation"]       = "orientation";
  m["Lockall"]           = "lockall";
  return m;
}

static DisplayAttributeCmdList DisplayAttributeCmd = create_display_attribute_cmd_map();



// Gary E. Christensen
// Date: 6/30/2010
// Purpose: make a global list of evaluator commands
//  If an evaluator command needs to be modified, it can be modified
//  here without having to change hard coded evaluator commands throughout
//  code.  Currently, the value and the tags are identical, but this
//  does not have to remain the case if someone wants to change the name
//  of a command such as to shorten it.
//  All values of list are lower case for string comparison to make case
//  insensitive

typedef std::map<std::string, std::string> EvaluatorCmdList;
static EvaluatorCmdList create_eval_cmd_map(){
  EvaluatorCmdList m;
  m["SpatialData"]                  = "spatialdata"; // 2 inputs: cs_id, label
  m["Transformation"]               = "transformation"; // 3 inputs: cs1_id, cs2_id, algo
  m["Diff"]                         = "diff"; // 2 inputs: image1, image2
  m["Disp0"]                        = "xdisp"; // 1 input: trans
  m["Disp1"]                        = "ydisp"; // 1 input: trans
  m["Disp2"]                        = "zdisp"; // 1 input: trans
  m["Jacobian"]                     = "jacobian"; // 1 input: trans
  m["TransformImage"]               = "transformimage"; // 3 inputs: image, trans, interp (NEED CHANGE)
  m["InvertTransformation"]         = "inverttransformation"; // 1 input: trans
  m["InverseConsistencyErrorImage"] = "inverseconsistencyerrorimage"; // 3 inputs: fwd_trans, rev_trans, method
  m["TransitivityErrorImage"]       = "transitivityerrorimage"; // 4 inputs: trans12, trans23, trans31, method
  m["IntensityVarianceTransform"]   = "intensityvariancetransform"; // 4 inputs: refimg, images, label, algo
  m["IntensityVarianceImage"]       = "intensityvarianceimage"; // 2 inputs: images, label
  m["TransformGrid"]                = "transformgrid";
  m["VectorField"]                  = "vectorfield";
  return m;
}

static EvaluatorCmdList EvalCmd = create_eval_cmd_map();



typedef std::multimap<std::string, std::string > EvaluatorInputList;
static EvaluatorInputList create_eval_input_map(){
  EvaluatorInputList m;
  m.insert(std::pair<std::string, std::string>(EvalCmd["SpatialData"],InputType["Cs_id"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["SpatialData"],InputType["Label"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["Transformation"],InputType["Cs_id"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["Transformation"],InputType["Cs_id"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["Transformation"],InputType["Algorithm"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["Diff"],InputType["Image"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["Diff"],InputType["Image"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["Disp0"],InputType["Transformation"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["Disp1"],InputType["Transformation"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["Disp2"],InputType["Transformation"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["Jacobian"],InputType["Transformation"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["TransformImage"],InputType["Image"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["TransformImage"],InputType["Transformation"]));
  //m.insert(std::pair<std::string, std::string>(EvalCmd["TransformImage"],InputType["Interpolation"]));  this is not implemented yet

  m.insert(std::pair<std::string, std::string>(EvalCmd["InvertTransformation"],InputType["Transformation"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["InverseConsistencyErrorImage"],InputType["Transformation"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["InverseConsistencyErrorImage"],InputType["Transformation"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["InverseConsistencyErrorImage"],InputType["Method"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["TransitivityErrorImage"],InputType["Transformation"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["TransitivityErrorImage"],InputType["Transformation"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["TransitivityErrorImage"],InputType["Transformation"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["TransitivityErrorImage"],InputType["Method"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["IntensityVarianceTransform"],InputType["Image"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["IntensityVarianceTransform"],InputType["Images"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["IntensityVarianceTransform"],InputType["Label"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["IntensityVarianceTransform"],InputType["Algorithm"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["IntensityVarianceImage"],InputType["Images"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["IntensityVarianceImage"],InputType["Label"]));

  return m;
}

static EvaluatorInputList EvalInput = create_eval_input_map();

// Jeffrey Hawley
// Date: 7/21/2010
// Purpose: make a global list of data types

typedef std::multimap<std::string, std::string> EvalOutputList;
static EvalOutputList create_eval_output_map(){
  EvalOutputList m;
  m.insert(std::pair<std::string, std::string>(EvalCmd["SpatialData"],InputType["Image"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["SpatialData"],InputType["Objectmap"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["Transformation"],InputType["Transformation"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["Diff"],InputType["Image"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["Disp0"],InputType["Image"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["Disp1"],InputType["Image"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["Disp2"],InputType["Image"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["Jacobian"],InputType["Image"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["TransformImage"],InputType["Image"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["InvertTransformation"],InputType["Image"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["InverseConsistencyErrorImage"],InputType["ICE"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["InverseConsistencyErrorImage"],InputType["Image"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["TransitivityErrorImage"],InputType["Image"]));
  m.insert(std::pair<std::string, std::string>(EvalCmd["TransitivityErrorImage"],InputType["TE"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["IntensityVarianceTransform"],InputType["Image"]));

  m.insert(std::pair<std::string, std::string>(EvalCmd["IntensityVarianceImage"],InputType["Image"]));
  return m;
}

static EvalOutputList EvalOutput = create_eval_output_map();


// Jeffrey Hawley
// Date: 7/21/2010
// Purpose: make a global list of data types

typedef std::map<std::string, std::string> DataTypeList;
static DataTypeList create_data_type_map(){
  DataTypeList m;
  m["Image"]                  = "image";
  m["Objectmap"]              = "objectmap";
  m["Transformation"]         = "transformation";

  //This will be uncommented when we implement these
  //in GenerateRDL, need to check to see if these are
  //used anywhere else like NIREPDataManager
  //m["Jacobin"]              = "jacobin";
  //m["TransformImage"]          = "transformimage";
  //m["ICEImage"]          = "ice_image";
  //m["TEImage"]          = "te_image";
  return m;
}

static DataTypeList DataType = create_data_type_map();


// Jeffrey Hawley
// Date: 7/21/2010
// Purpose: make a global list of format types

typedef std::map<std::string, std::string> TransformFormatList;
static TransformFormatList create_transform_format_map(){
  TransformFormatList m;
  m["Displacement"]        = "displacement";
  m["Displacement3"]       = "displacement3";
  m["SICLE_coeff"]         = "sicle_coeff";
  m["Air5"]                = "air5";
  return m;
}

static TransformFormatList TransformFormat = create_transform_format_map();

// Jeffrey Hawley
// Date: 7/21/2010
// Purpose: make a global list of format types

typedef std::map<std::string, std::string> TransformUnitsList;
static TransformUnitsList create_transform_units_map(){
  TransformUnitsList m;
  m["Unit_cube"]        = "unit_cube";
  m["Physical_space"]       = "physical_space";
  m["Image_space"]         = "image_space";
  return m;
}

static TransformUnitsList TransformUnits = create_transform_units_map();


// Jeffrey Hawley
// Date: 8/12/2010
// Purpose: make a global list of extensions

typedef std::multimap<std::string, std::string> FileExtensionList;
static FileExtensionList create_file_extension_map(){
  FileExtensionList m;
  m.insert(std::pair<std::string, std::string>("hdr", DataType["Image"]));

  m.insert(std::pair<std::string, std::string>("img",DataType["Image"]));

  m.insert(std::pair<std::string, std::string>("nii",DataType["Image"]));
  m.insert(std::pair<std::string, std::string>("nii.gz",DataType["Image"]));
  m.insert(std::pair<std::string, std::string>("raw",DataType["Image"]));

  m.insert(std::pair<std::string, std::string>("obj",DataType["Objectmap"]));

  m.insert(std::pair<std::string, std::string>("lmk","Landmark"));

  m.insert(std::pair<std::string, std::string>("coeff",DataType["Transformation"]));//"Sicle"));
  m.insert(std::pair<std::string, std::string>("coeff",TransformFormat["SICLE_coeff"]));

  m.insert(std::pair<std::string, std::string>("warp",DataType["Transformation"]));//"AIR"));
  m.insert(std::pair<std::string, std::string>("warp",TransformFormat["Air5"]));
  return m;
}

static FileExtensionList FileExtension = create_file_extension_map();

typedef std::map<std::string, std::string> InterpolationTypeList;
static InterpolationTypeList create_interpolation_type_map(){
  InterpolationTypeList m;
  m["Linear"] = "linear";
  m["Nearest Neighbor"] = "nearest neighbor";
  return m;
}

static InterpolationTypeList InterpolationType = create_interpolation_type_map();



//----------------------------------------------------------------------------------------
//We want to depreciate this and use the wxString CmpNoCase
//Instead of using CaseInsensitiveFind function use the following code:
//wxString string1 = "Hello";
//wxString string2 = "hello";
//if(string2.CmpNoCase(string1) == 0) {
//    success
//} else { 
//    fail 
//}

static bool CaseInsensitiveFind(std::string string1, std::string string2){

  // Convert string1 to lower case for comparison
  std::transform(string1.begin(), string1.end(), string1.begin(), tolower);
  std::transform(string2.begin(), string2.end(), string2.begin(), tolower);
  //wxString temp_str = (wxT(string1.c_str()));
  //temp_str.Trim(true);
  //temp_str.Trim(false);
  //string1 = temp_str.c_str();

  // Trim spaces from left and right side of string2
  // Don't need to do this for string1 because we are looking
  // for string2 inside of string1
  wxString temp_str(string2.c_str(), wxConvUTF8);
  temp_str.Trim(true);
  temp_str.Trim(false);
  string2 = std::string(temp_str.mb_str());

  size_t found = string1.find(string2);

  // found equals npos if string2 is not found in string1
  if (found == std::string::npos){
    return false;
  } else {
    return true;
  }

}

#endif