C:/Programs/source/NIREP/Evaluator/NIREPEvaluator.h

#pragma once
#ifndef _NIREP_EVALUATOR_H_
#define _NIREP_EVALUATOR_H_

/* +-----------+
   | Libraries |
   +-----------+ */
// standard libraries
#include <iostream>
#include <map>
#include <vector>
#include <string>

// our libraries
#include "gecSpatialData.h"
#include "gecImage.h"
#include "gecObjectMap.h"
#include "gecTransformation.h"
//#include "gecMath.h"
#include "gecJacobian.h"
#include "NIREPDataManager.h"
#include "DisplayDescription.h"
#include <vtkImageFlip.h>


/* +---------+
   | Classes |
   +---------+ */
// Forward declarations
class Panel;


struct TextTable {
  std::string Title;                 //Title displayed in the text widgets.  For example:
                                     // Inverse Consistency Error NA01 to NA02 to NA01
                                     // using h(g(x))-x method

  std::vector<std::string> ColumnHeading;  //Heading displayed above the value(s)
                                           //example: Average     Variance    Max

  std::vector< std::vector<float> > Value;  //Row(s) of value(s) appearing under each heading
                                          //example:  .01         .02         .05
                                          
  
};

class NIREPEvaluator
{
  public:

    
  
  /* +----------------+
     | Public Methods |
     +----------------+ */

  NIREPEvaluator(void);
  
  NIREPEvaluator(NIREPDataManager* dm);

  ~NIREPEvaluator(void);

  //void SetTaskList(EvaluatorList* list)
  //{
  //  this->taskList = list;
  //};

  //EvaluatorList* GetTaskList()
  //{
  //  return this->taskList;
  //};


  vtkImageData* GetImage(Panel* p, const std::string& command, DisplayDescription * displayDescription)
  {
    if(this->Evaluate(command, displayDescription) == NULL) {
      return NULL;
    }
    return dynamic_cast<vtkImageData *>(this->Evaluate(command, displayDescription)->GetVTKData());
    // NOTE:  The above code causes the reference count in the Display manager by 2.
  };

  gec::ObjectMap* GetObjectMap(Panel* p, const std::string& command, DisplayDescription * displayDescription)
  {
    return dynamic_cast<gec::ObjectMap *>(this->Evaluate(command, displayDescription));
  };

  gec::SpatialData* GetSpatialData(const std::string& command, DisplayDescription * displayDescription)
  {
    return this->Evaluate(command, displayDescription);
  };

  unsigned long GetMemoryUsage(){return this->dataManager->GetMemoryUsage();};

  gec::SpatialData* ReadSpatialData(const std::string& datasetID,
                                    const std::string& dataID,
                                    DisplayDescription * displayDescription);

  // \fn ReadTransformation
  gec::SpatialData* ReadTransformation(const std::string& source,
                                       const std::string& target,
                                       const std::string& transformation,
                                       DisplayDescription * displayDescription);

  NIREPDataManager* GetDataManager(){return dataManager;};

  gec::SpatialData* TransformGrid(const std::string& transformID, DisplayDescription * displayDescription);

  gec::SpatialData* VectorField(const std::string& transformID, DisplayDescription * displayDescription);


  private:

  /* +----------+
     | typedefs |
           +----------+ */

  /* +-----------------+
     | Private Methods |
     +-----------------+ */
    
  void Init();

  gec::SpatialData* Evaluate(const std::string& command, DisplayDescription * displayDescription);

  gec::SpatialData* Diff(const std::string& img1, const std::string& img2, DisplayDescription * displayDescription);

  gec::SpatialData* Disp(const std::string& transformID, const unsigned int& index, DisplayDescription * displayDescription);

  gec::SpatialData* Jacobian(const std::string& transformID, DisplayDescription * displayDescription);

  gec::SpatialData* Transform(const std::string& imageID, const std::string& transformID, DisplayDescription * displayDescription);

  gec::SpatialData* InvertTransformation(const std::string& transformID, DisplayDescription * displayDescription);

  gec::SpatialData* InverseConsistencyError(const std::string& fwdTransID,
                                            const std::string& revTransID,
                                            const std::string& method,
                                            DisplayDescription * displayDescription);

  gec::SpatialData* TransitivityError(const std::string& transABID,
                                      const std::string& transBCID,
                                      const std::string& transACID,
                                      const std::string& method,
                                      DisplayDescription * displayDescription);

  gec::SpatialData* IntensityVariance(std::vector<std::string>& arg,
                                      std::string version, 
                                      DisplayDescription * displayDescription);

  /* +--------------------+
     | Private Parameters |
     +--------------------+ */
  //EvaluatorList* taskList;          ///@taskList reference to the evaluator list
  NIREPDataManager* dataManager;    
};

#endif