creaImageIOGimmickView.h

Go to the documentation of this file.

#ifndef __creaImageIOGimmickView_h_INCLUDED__
#define __creaImageIOGimmickView_h_INCLUDED__

#include <creaImageIOGimmick.h>
#include <creaImageIOTreeView.h>
#include <creaImageIOSystem.h>
#include <creaImageIOImagePointerHolder.h>

//#include <map>
#include <vtkImageData.h>
#include <creaImageIOMultiThreadImageReader.h>

// Signal/slot mechanism for progress events
#include <boost/signal.hpp>
#include <boost/bind.hpp>

#define GIMMICK_NO_IMAGE_SELECTION 0
#define GIMMICK_2D_IMAGE_SELECTION 2
#define GIMMICK_3D_IMAGE_SELECTION 3
#define GIMMICK_4D_IMAGE_SELECTION 4

#define NATIVE 0
#define _2D 2
#define _3D 3


namespace creaImageIO
{
        class ImageExtent;
    //=====================================================================
    
    //=====================================================================
        class GimmickView: public MultiThreadImageReaderUser
    {
    public:
      GimmickView(Gimmick*, int number_of_threads = 0 );
      virtual ~GimmickView();
      virtual void Initialize();

      typedef std::map<std::string, TreeView*> TreeViewMapType;
      
      TreeViewMapType& GetTreeViewMap() { return mTreeViewMap; }
      const TreeViewMapType& GetTreeViewMap() const
      { return mTreeViewMap; }

      virtual void Finalize();

          //Returns the maximal priority
          int GetMaximalPriority(){return mReader.GetMaximalPriority();}

      virtual void GetSelectedImages(std::vector<vtkImageData*>& s, int dim) 
          { GimmickError("INTERNAL ERROR : GetSelectedImages not implemented"); }

      virtual void GetSelectedFiles(std::vector<std::string>& s)
      { GimmickError("INTERNAL ERROR : GetSelectedFiles not implemented"); }

          virtual void GetImages(int dim, std::vector<std::string> files, std::vector<vtkImageData*>& s) 
          { GimmickError("INTERNAL ERROR : GetImages not implemented"); }

      virtual void OnSelectionChange(const std::vector<tree::Node*>& s, bool isSelection, int selection, bool mProcess)
      { GimmickError("INTERNAL ERROR : OnSelectionChange not implemented"); }

           virtual void ClearSelection()
      { GimmickError("INTERNAL ERROR : ClearSelection not implemented"); }

          virtual void AddIgnoreFile(tree::Node* toRemove)
          { GimmickError("INTERNAL ERROR : AddIgnoreFile not implemented"); }
      
          virtual void CopyFiles(const std::vector<std::string>& filenames)
          { GimmickError("INTERNAL ERROR : CopyFiles not implemented"); }

          virtual void CreateEditFieldsDialog(tree::Node* node, std::vector<std::string> names, std::vector<std::string> keys)
          { GimmickError("INTERNAL ERROR : EditFields not implemented"); }
      
      bool ValidateSelected (tree::Node* sel, int min_dim, int max_dim);
      
          void ReadImagesNotThreaded(std::vector<vtkImageData*>& s,std::vector<std::string> files, int dim);
      void RequestReading(tree::Node* n, int prio, int selection_index , ImagePointerHolder *p);
     
      
      std::string GetMessage(){return mMess;}
      void SetMessage(std::string mess){mMess=mess;}
          void ResetExtent();

      void CreateTreeViews();

          void CreateSingleTreeView(std::string &i_name);

      virtual void CreateTreeView( TreeHandler* ) 
      { GimmickError("INTERNAL ERROR : CreateTreeView not implemented"); }

      virtual void UpdateTreeViewLevel(const std::string&, int l);
          // Multi-thread image reader callback
          void OnMultiThreadImageReaderEvent(const std::string& filename,
                                       MultiThreadImageReaderUser::EventType t,
                                       vtkImageData* image);

      vtkImageData* GetDefaultImage() { return mReader.GetImage(""); }


      //=============================================
      typedef boost::signal<void (bool)>  ValidationSignalType;
      typedef ValidationSignalType::slot_function_type ValidationCallbackType;
      //=============================================

     //==================================================================
      void ConnectValidationObserver(ValidationCallbackType callback);
     //==================================================================

          

        void modifyValidationSignal(bool ivalid);

    private:
        
      Gimmick* mGimmick;
      TreeViewMapType mTreeViewMap;
      std::string mMess;

      MultiThreadImageReader mReader;
      struct ImageEventType
      {
        ImageEventType( tree::Node* no = 0,   
                        int sel_index = -1,
                        ImagePointerHolder* ph= 0)
          : node(no), index(sel_index),  pointerHolder(ph){}
        ImageEventType(vtkImageData* im )
          : image(im) {}
        tree::Node* node;
        vtkImageData* image;
                int index;
                ImagePointerHolder* pointerHolder;
      };
      typedef std::map<std::string,ImageEventType> ImageEventTypeMap;
      ImageEventTypeMap mImageEventMap;
      // queue of image event 
      typedef std::deque<ImageEventType> ImageEventQueueType;
      //ImageEventQueueType mImageEventQueue;

          ImageExtent* mImageExtent;
          ValidationSignalType mValidationSignal;
          bool valid;
          bool mReaderStarted;
      
        };
  // EO class GimmickView
    //=====================================================================
  

  /*








        //====================================================================
        // General
        //====================================================================

    virtual int GetSelectionSize() { return 0; } 
    virtual bool IsSelectionValid(){ return false; }
    virtual void GetSelectedFiles(std::vector<std::string>&){ return; }
    virtual void GetSelectedImages(std::vector<vtkImageData*>&){ return; }
    virtual void GetSelectedDicomNodes(std::vector<DicomNode*>&){ return; }
    virtual DicomNode* GetDicomNodeOfItem(const TreeItemId& i);

        
    typedef std::vector<DicomDatabase*> DicomDatabaseListType;
    virtual DicomDatabaseListType& GetDicomDatabaseList() 
    { return null; }
    virtual const DicomDatabaseListType& GetDicomDatabaseList() const 
    { return null; }

        protected:
    virtual void OpenOrNewDatabase(bool open){ return; }
        virtual void ShowHelp();

        private:
        const std::string& GetDatabaseExtension() { return null; }
    virtual void SetDatabaseExtension(const std::string& ext){ return; }


        //====================================================================
    // Preview Display Related
        //====================================================================


        private:
         virtual void ShowImage(vtkImageData* image){ return; }

        //====================================================================
    // Favorites Related
        //====================================================================


        public:
    virtual void LoadOrCreateFavoritesDatabase(){ return; }
        private:
    void CreateUserSettingsDirectory(){ return; }
        const std::string& GetUserSettingsDirectory(){ return null; }

        //====================================================================  
        // Attribute Display Related
        //====================================================================


        private:
     virtual void ShowInformation(DicomNode*){ return; }
   
        //====================================================================
    // Tree Display Related
    //====================================================================

        protected:
    virtual void RebuildView(){ return; }
    virtual void UpdateDicomDatabaseView(DicomDatabase*){ return; }
        virtual void UpdateDicomNodeView(DicomNode* n, const TreeItemId& parent){ return; }
    
        private:
    typedef WxGimmickTreeItemData TreeItemData;
    TreeItemData* GetItemData(const TreeItemId& id){ return null; }
    typedef WxGimmickDicomNodeData NodeData;


        //====================================================================
    // Class Attributes
    //====================================================================

        
        int mSelectionType;
    int mSelectionMaxImageDimension;
    int mCurrentSelectionImageSize[4];

    DicomDatabaseListType mDicomDatabaseList;
    DicomDatabase* mFavoriteDatabase;

    std::string mDatabaseListFile;
    std::string mDatabaseExtension;

    bool mJustStarted;

    int  mFirstDicomDatabaseIconIndex;

   // Previewer
    vtkImageViewer2* mViewer;
    
    int mx1,mx2,my1,my2,mz1,mz2;
    double mspx,mspy,mspz;
  
    // Image preview :
    // Multi-thread image reader
    MultiThreadImageReader mReader;
    // map of images name to node
    std::map<std::string,DicomNode*> mImageFileNameToNode;
  */
 
} // EO namespace creaImageIO

// EOF
#endif

---