C:/cmcintos/defOrgs/examples/DefOrgViewerWithKW/Source/DefOrgViewerAdapterBase.h

#ifndef __DefOrgViewerAdapterBase_h
#define __DefOrgViewerAdapterBase_h

#include "itkImageFileReader.h"
#include "itkImageFileWriter.h"
#include "itkMeanImageFilter.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkCovariantVector.h"

#include "vtkUnstructuredGrid.h"
#include "vtkCellArray.h"
#include "vtkProperty.h"
#include "vtkTransform.h"

#include <iostream>
#include <map>
#include <vector>
#include "itkSceneSpatialObject.h"
#include "itkImage.h"
#include "itkImageFileReader.h"
#include "vtkImageImport.h"
#include "itkVTKImageExport.h"
#include "DefOrgViewerAdapterBase.h"

#include <vtksys/SystemTools.hxx>
#include <vtksys/CommandLineArguments.hxx>

namespace mial{
#define N_DIMS 3
typedef itk::SceneSpatialObject<N_DIMS>::Pointer                itkScenePointer;

#define SetStringMacro(name) \
  virtual void Set##name (const char* _arg) \
  { \
    if ( _arg && (_arg == this->m_##name) ) { return;} \
    if (_arg) \
      { \
      this->m_##name = _arg;\
      } \
     else \
      { \
      this->m_##name = ""; \
      } \
    m_Initialized=false; \
  } 

struct DefOrgLayerStruct{
        const char* layerName;
        std::vector<const char*> options;
        const char* chosenOption;       
};


struct DefOrgPropertyStruct{
        double lowerBound;
        double upperBound;
        double defaultValue;
        double currentValue;
        double resolution;
        std::string helpString;
        DefOrgPropertyStruct(double _lowerBound, double _upperBound, double _defaultValue, double _currentValue, double _resolution, std::string _helpString):
                lowerBound(_lowerBound),
                upperBound(_upperBound),
                defaultValue(_defaultValue),
                currentValue(_currentValue),
                resolution(_resolution),
                helpString(_helpString)
        {}
        DefOrgPropertyStruct():
                lowerBound(0),
                upperBound(100),
                defaultValue(50),
                currentValue(50),
                resolution(1),
                helpString("Program Error: Incorrectly initialized.")           
        {}
};

struct SpatialObjectDescriptorStruct{
        itkScenePointer theItkScene;
        bool isModified;
        bool displayInSeparateFrame;
        SpatialObjectDescriptorStruct(itkScenePointer _theItkScene, bool _displayInSeparateFrame, bool _isModified=true):
                theItkScene(_theItkScene),
                isModified(_isModified),
                displayInSeparateFrame(_displayInSeparateFrame)
        {}
        SpatialObjectDescriptorStruct():
                theItkScene(NULL),
                isModified(false),
                displayInSeparateFrame(false)
        {}
};

struct OutputImageDescriptorStruct{
        vtkImageImport* theImageVolume;
        bool isModified;
        bool isInitialized;
        int      dimension;
        std::string windowName;
        bool displayInSeparateFrame;
        OutputImageDescriptorStruct(vtkImageImport* _theImageVolume, bool _displayInSeparateFrame, int _D, bool _isModified=true):
                theImageVolume(_theImageVolume),
                isModified(_isModified),
                isInitialized(false),
                dimension(_D),
                windowName("Window"),
                displayInSeparateFrame(_displayInSeparateFrame)
        {}
        OutputImageDescriptorStruct():
                theImageVolume(NULL),
                isModified(false),
                isInitialized(false),
                dimension(0),
                windowName(""),
                displayInSeparateFrame(false)
        {}
};

class DefOrgViewerAdapterBase{
public:
        //typedef void (* DEFORG_TEXTOUTPUT_CALLBACK_FUNCTION)();
        DefOrgViewerAdapterBase(int maxNumImages):m_Initialized(false){
                std::cout.rdbuf(theDefOrgTextOutput.rdbuf());
                for(int i=0; i<maxNumImages;i++)
                        m_OutputImages.push_back(OutputImageDescriptorStruct(NULL,false,0));
        }
        SetStringMacro(ScheduleFileName);
        SetStringMacro(MeshFileName);
        SetStringMacro(ImageFileName);

        virtual bool IsAllInputFilesSet(){
                return 
                (vtksys::SystemTools::FileExists(m_ImageFileName.c_str()) &&
                vtksys::SystemTools::FileExists(m_ScheduleFileName.c_str()) &&
                vtksys::SystemTools::FileExists(m_MeshFileName.c_str()) 
                );
        }       
        /*
        virtual bool IsInitialized(){
                return m_Initialized;
        }*/

        virtual void SetupOrganism()=0;
        virtual void UpdateOrganism()=0;
        virtual void PopulateVtkImage()=0;
        virtual void PopulateVtkUnstructuredGrid(vtkUnstructuredGrid* vtkGrid /*in/out*/)=0;
        virtual void PopulateItkScene()=0;

        virtual void HandleUserMouseInteraction(vtkTransform* userTransformation)=0;

        virtual int MaxNumberOfOutputItkSpatialObjects()=0;
        virtual unsigned int MaxNumberOfOutputImages()=0;

        std::map<std::string,DefOrgPropertyStruct> m_PropertyBag;

        std::vector< DefOrgLayerStruct > m_LayerBag;
        std::vector< SpatialObjectDescriptorStruct > m_OutputItkSpatialObjects;
        std::vector< OutputImageDescriptorStruct > m_OutputImages;

        virtual void AddOutputItkSpatialObjects(itkScenePointer itkScene){
                m_OutputItkSpatialObjects.push_back(SpatialObjectDescriptorStruct(itkScene,false));
        }
        
        virtual void AddOutputImages(vtkImageImport* vtkImporter,int Offset){
                m_OutputImages[Offset].theImageVolume = vtkImporter;
        }

        std::ostringstream theDefOrgTextOutput;
        std::stringstream theDefOrgTextInput;
        //DEFORG_TEXTOUTPUT_CALLBACK_FUNCTION theDefOrgTextOutputCallBack;

protected:      
        bool m_Initialized;
        virtual void AddOrganismProperty(const char* propertyName, double lowerBound,   double upperBound, double defaultValue, double resolution=1.0, const char* helpString=""){
                m_PropertyBag[propertyName]=DefOrgPropertyStruct(lowerBound,upperBound,defaultValue,defaultValue,resolution,std::string(helpString));
        }
        virtual double GetOrganismProperty(const char* propertyName){
                std::map<std::string,DefOrgPropertyStruct>::iterator cur = m_PropertyBag.find(std::string(propertyName));
                if ( m_PropertyBag.end()!= cur){
                        return (cur->second).currentValue;
                }
                return 0;
        }

        virtual void AddLayer(const char* layerName, const char** options, int numChoices);

        virtual const char* GetLayer(const char* layerName);

        std::string m_ImageFileName;
        std::string m_ScheduleFileName;
        std::string m_MeshFileName;             
        
        
};
}
#endif

---