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>
#if defined (USE_WXWIDGETS)
#include <creaImageIOMultiThreadImageReader.h>
#endif

#if defined(USE_QT4)
#include <creaImageIOQMultiThreadImageReader.h>
#endif


// 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
{
        typedef std::map<std::string, std::string> mapInfoDicom;

        typedef struct 
        { 
                vtkImageData *img;
                //std::map<std::string, std::string> infos;
                mapInfoDicom infos; 
        } OutStrGimmick;


        class ImageExtent;
    //=====================================================================
    
    //=====================================================================
        class GimmickView: public MultiThreadImageReaderUser
    {
    public:
      GimmickView(boost::shared_ptr<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();

      int GetMaximalPriority(){return mReader.GetMaximalPriority();}

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

      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"); }
      
          virtual void Anonymize(std::vector<std::string> i_filenames, int type)
          { GimmickError("INTERNAL ERROR : Anonymize not implemented"); }

          virtual void DumpTags(const std::string filename)
          {GimmickError("INTERNAL ERROR : DumpTags not implemented"); }
          
          virtual void ExportToStorage(const std::vector<std::string> keys)
          { GimmickError("INTERNAL ERROR : ExportToStorage not implemented"); }
      
          virtual void SaveAs(const std::vector<std::string>& filenames)
          { GimmickError("INTERNAL ERROR : SaveAs not implemented"); }

          bool NoValidateSelected();

      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 ReadImagesNotThreadedInVector(std::vector<vtkImageData*>& s,std::vector<std::string> files, int dim);

      //void RequestReading(tree::Node* n, int prio, int selection_index , ImagePointerHolder *p);
          void RequestReading(tree::Node* n, int prio, int selection_index , boost::shared_ptr<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);

        
        void readImages(std::vector<OutStrGimmick>& o_output, std::vector<std::string> im,
                         OutputAttr i_attr, int i_dim, double i_zspc);
                        bool isSingle(const std::string i_file);

        void stopReader();
    private:


        typedef void (*readXD)(std::vector<OutStrGimmick>&,  std::vector<std::string>, OutputAttr, double);

        void getAttributes(const std::string i_file, std::map<std::string, std::string> &o_infos, OutputAttr i_attr);

        virtual void readImages2(std::vector<OutStrGimmick>& o_output, std::vector<std::string> im,
                         OutputAttr i_attr, double i_zspc);

        virtual void readImages3(std::vector<OutStrGimmick>& o_output, std::vector<std::string> im,
                         OutputAttr i_attr, double i_zspc);

        virtual void readImages4(std::vector<OutStrGimmick>& o_output, std::vector<std::string> im,
                         OutputAttr i_attr);

        virtual void readImages1(std::vector<OutStrGimmick>& o_output, std::vector<std::string> im,
                         OutputAttr i_attr);


      boost::shared_ptr< 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;
                boost::shared_ptr<ImagePointerHolder> pointerHolder;
      };
      typedef std::map<std::string,ImageEventType> ImageEventTypeMap;
      ImageEventTypeMap mImageEventMap;

      // queue of image event 
      typedef std::deque<ImageEventType> ImageEventQueueType;

      //ImageEventQueueType mImageEventQueue;

          boost::shared_ptr<ImageExtent> mImageExtent;

          ValidationSignalType mValidationSignal;

          bool valid;

          bool mReaderStarted;

        };
  // EO class GimmickView
    //=====================================================================

 
} // EO namespace creaImageIO

// EOF
#endif