]> Creatis software - creaImageIO.git/blob - src2/creaImageIOGimmickView.cpp
5da98b5c47d289f80b9300db674fe7c05dfe46e8
[creaImageIO.git] / src2 / creaImageIOGimmickView.cpp
1 #include <creaImageIOGimmickView.h>
2 #include <creaImageIOSystem.h>
3
4 #include "boost/filesystem.hpp"
5
6 namespace fs = boost::filesystem;
7
8 namespace creaImageIO
9 {
10
11   //======================================================================
12   // CTor
13   GimmickView::GimmickView(Gimmick* gimmick, int threads)
14     : mGimmick(gimmick),
15           mReader(threads)
16   {
17     GimmickDebugMessage(1,"GimmickView::GimmickView"
18                         <<std::endl);
19         // Anciently started the threads ...
20     // Threads now automatically start at first image request
21     //mReader.Start();
22
23   }
24   //======================================================================
25
26   //======================================================================
27   /// Destructor
28   GimmickView::~GimmickView()
29   {
30     GimmickDebugMessage(1,"GimmickView::~GimmickView"
31                         <<std::endl);
32   }
33    //======================================================================
34  
35   //======================================================================  
36   /// Initializes the view : 
37   /// Creates the TreeViews for all the TreeHandler of the Controller
38   /// 
39   void GimmickView::Initialize()
40   {
41           row="";
42           col="";
43           plane="";
44           selectionSize=0;
45   }
46   //======================================================================
47   
48   //======================================================================
49   /// Finalize 
50   void GimmickView::Finalize()
51   {
52   }
53
54   //======================================================================
55
56   //======================================================================
57   /// Create the tree views 
58   void GimmickView::CreateTreeViews()
59   {
60     GimmickMessage(2,"Creating the tree views"<<std::endl);
61     Gimmick::TreeHandlerMapType::const_iterator i;
62     for (i = mGimmick->GetTreeHandlerMap().begin();
63          i!= mGimmick->GetTreeHandlerMap().end();
64          ++i)
65       {
66         this->CreateTreeView(i->second);
67       }
68   }
69   //======================================================================
70
71   //======================================================================
72   /// Updates the TreeView of given name from level l to bottom
73   /// (calls the virtual method TreeView::Update())
74   void GimmickView::UpdateTreeViewLevel(const std::string& t, int l)
75   {
76     TreeViewMapType::iterator i;
77     i = GetTreeViewMap().find(t);
78     if ( i == GetTreeViewMap().end() )
79       {
80         GimmickError("INTERNAL ERROR : GimmickView::UpdateTreeView : '"
81                      <<t<<"' is not in TreeViewMap");
82       }
83     i->second->UpdateLevel(l);    
84   }
85   //======================================================================
86   /// Clears the status and begins a new selection process
87   void GimmickView::ClearStatus()
88   {
89           row="";
90           col="";
91           plane="";
92           selectionSize=0;
93           valid=true;
94   }
95   //======================================================================
96   ///Validates the dimension compliance of the images with the maximum and 
97   ///minimum given, and between their sizes
98   bool GimmickView::ValidateSelected (tree::Node* sel, int min_dim, int max_dim)
99   {
100         GimmickMessage(2,"Validating selected"<<std::endl);
101         std::string mMessage;
102         if(sel==0)
103         {
104                 mMessage="Cannot have 0 images selected!";
105                 valid=false;
106         }
107         if(valid)
108         {
109         selectionSize++;
110           /*// EED validate all
111           mValidationSignal(valid);
112           return valid;*/
113           
114         int level;
115         
116         
117         if(row.compare("")==0 || col.compare("")==0)
118         {
119                 row=(*sel).GetAttribute("D0028_0010");
120                 col=(*sel).GetAttribute("D0028_0011");
121                 plane=(*sel).GetAttribute("D0028_0012");
122                 level=(*sel).GetLevel();
123         }
124         else
125         {
126                 if(((*sel).GetAttribute("D0028_0010"))!=row ||
127                         ((*sel).GetAttribute("D0028_0011"))!=col ||
128                         ((*sel).GetAttribute("D0028_0012"))!=plane)
129                         {
130                                 mMessage="The selected images are not compatible.";
131                                 valid=false;
132                         }
133         }
134                 
135
136                 //Dimention validation
137                 //Compatibility with maximum and minimum
138                         if(valid)
139                         {       
140                                 
141                                 int rows;
142                                 int cols;
143                                 int planes;
144                                 std::string s;
145                                 std::istringstream t(s);
146                                 s=row;
147                                 t >> rows;
148                                 if(row==""){rows=1;}
149                                 s=col;
150                                 t >> cols;
151                                 if(col==""){cols=1;}
152                                 s=plane;
153                                 t >> planes;
154                                 if(plane==""){planes=1;}
155
156                                 int dim = 0;
157                                 if (planes>1) dim=3;
158                                 else if (cols>1) dim=2;
159                                 else if (rows>1) dim=1;
160                             
161                                 if (dim == 0) 
162                                 {
163                                         mMessage="Unknown image dimension : cannot select !";
164                                         valid= false;
165                                 }
166                                 else if (dim>max_dim)
167                                 {
168                                         mMessage="Selecting ";
169                                         mMessage+=dim;
170                                         mMessage+="D images is not allowed !";
171                                         valid= false;
172                                 }
173                                 if ( dim == max_dim )
174                                 {
175                                         mMessage="Cannot add this image to selection : would result in a ";
176                                         mMessage+=(dim+1);
177                                         mMessage+="D image!";
178                                         
179                                         valid= false;
180                                 }
181                                 if ( dim < min_dim )
182                                 {
183                                         GimmickMessage(1, "State Check: Dim: "
184                                                 <<dim
185                                                 <<" Dim min:"
186                                                 <<min_dim
187                                                 <<std::endl);
188                                         mMessage="Cannot build the selection as it would result in a ";
189                                         std::string a;
190                                         std::stringstream out;
191                                         out<<dim;
192                                         a=out.str();
193                                         mMessage+=a;
194                                         mMessage+="D image, and the minimum is ";
195                                         out<<min_dim;
196                                         a=out.str();
197                                         mMessage+=a;
198                                         mMessage+="D!";
199                                         valid= false;
200                                 }
201                         }
202         
203         
204         if(valid)
205         {
206                 mMessage="Selection OK !";
207         }
208         }
209         mValidationSignal(valid);
210         SetMessage(mMessage);
211         return valid;
212   }
213
214    //======================================================================
215
216    //======================================================================
217   ///Reads Images (Non Threaded)
218   void GimmickView::ReadImagesNotThreaded(std::vector<vtkImageData*>& s,std::vector<tree::Node*> im, int dimension)
219   {
220           
221         // Create the output data
222         if (im.size()==1) 
223       {
224                   
225                 // Only one image : give it
226                 vtkImageData* out = vtkImageData::New();
227                 GimmickMessage(1, "State Check: Full Filename: "
228                                                 <<im.front()->GetAttribute("FullFileName")
229                                                 <<std::endl);
230                 out->ShallowCopy(mReader.GetImage(im.front()->GetAttribute("FullFileName")));
231                 s.push_back( out );
232       }
233           
234     else if (im.size()>1)
235       {
236         vtkImageData* first = mReader.GetImage( im.front()->GetAttribute("FullFileName"));
237         if (dimension==2) 
238           {     
239             // n2D to 3D
240             vtkImageData* out = vtkImageData::New();
241             out->CopyStructure(first);  
242             out->SetScalarType(first->GetScalarType());
243             int ext[6];
244             first->GetExtent(ext);
245             ext[5] = im.size();
246             out->SetExtent(ext);
247             // LG : TODO : Z Spacing  ?
248             
249             out->AllocateScalars();
250             
251             //first->Print(std::cout);
252             //      out->Print(std::cout);
253             
254             int dim[3];
255             first->GetDimensions(dim);
256             unsigned long imsize = 
257               ( (unsigned long)first->GetScalarPointer(0,1,0)
258                 - (unsigned long)first->GetScalarPointer(0,0,0))
259               *dim[1];
260
261             int slice = 0;
262                 std::vector<tree::Node*>::iterator it;
263             for (it=im.begin(); it!=im.end(); ++it) 
264               {
265                 //std::cout << "copying slice "<<slice <<std::endl;
266                           vtkImageData* cur = mReader.GetImage( (*it)->GetAttribute("FullFileName"));
267                 
268                 void* src = cur->GetScalarPointer(0,0,0);
269                 void* dst = out->GetScalarPointer(0,0,slice);
270                 //              std::cout << "src="<<src<<std::endl;
271                 //              std::cout << "dst="<<dst<<std::endl;
272                 //              std::cout << "siz="<<imsize<<std::endl;
273                 memcpy(dst,src,imsize);
274
275                 slice++;
276               }
277             s.push_back(out);
278           }
279         else 
280           {
281             // n3D
282                   std::vector<tree::Node*>::iterator it;
283             for (it=im.begin(); it!=im.end(); ++it) 
284               {
285                 vtkImageData* out = vtkImageData::New();
286                 out->ShallowCopy(mReader.GetImage((*it)->GetAttribute("FullFileName")));
287                 s.push_back(out);
288               }
289           }
290       }
291         
292   }
293   //======================================================================
294
295   //======================================================================
296   ///Requests the reading of an image
297   void GimmickView::RequestReading(tree::Node* n, 
298                                    int prio, int selection_index, ImagePointerHolder *p)
299   {
300         mReader.Start();
301     ImageEventType t(n,selection_index, p);
302     mImageEventMap[n->GetAttribute("FullFileName")] = t;    
303     mReader.Request(this,n->GetAttribute("FullFileName"),prio);
304   }
305   //======================================================================
306
307   //======================================================================
308   void GimmickView::
309   OnMultiThreadImageReaderEvent(const std::string& filename,
310                                 MultiThreadImageReaderUser::EventType e,
311                                 vtkImageData* image)
312   {
313     GimmickDebugMessage(7,
314                         "MultiThreadImageReader event : "<<e<<std::endl);
315         if (e==ImageLoaded)
316         {
317     if (filename.size()==0)
318       {
319                   //What to do in this case?
320                   /*
321                 GimmickDebugMessage(5,
322                                         "Pushing unknown image in queue"
323                                         <<std::endl);
324                 mImageEventQueue.push_back(ImageEventType(image));*/
325                 return;
326       }
327     ImageEventTypeMap::iterator i;
328     i = mImageEventMap.find(filename);
329     if (i!=mImageEventMap.end())
330       {
331                 GimmickDebugMessage(5,
332                                         "Putting image of file '"<<filename<<"' on pointer"
333                                         <<std::endl);
334                 ImageEventType ie(i->second);
335                 ie.image = image;
336                 ie.pointerHolder->Set(ie.image);
337                 //mImageEventMap.erase(i);
338       }
339         }
340         else if (e==Error)
341         {
342                 std::string mess="ERROR: MultiThreadImageReader: Cannot read image in file ";
343                 mess+=filename;
344                 mess+="\n";
345                 GimmickMessage(1,mess);
346                 ImageEventTypeMap::iterator i;
347                 i = mImageEventMap.find(filename);
348                 if (i!=mImageEventMap.end())
349                 {
350                 ImageEventType ie(i->second);
351                 ie.image = image;
352                 ie.pointerHolder->Set(GetDefaultImage());
353                 //mImageEventMap.erase(i);
354                 }
355         }
356
357         else if (e==ImageUnloaded)
358         {
359                 std::string mess="Unloaded image in file ";
360                 mess+=filename;
361                 mess+="\n";
362                 GimmickMessage(1,mess);
363                                 ImageEventTypeMap::iterator i;
364                 i = mImageEventMap.find(filename);
365                 if (i!=mImageEventMap.end())
366                 {
367                 ImageEventType ie(i->second);
368                 ie.image = image;
369                 ie.pointerHolder->Set(GetDefaultImage());
370                 //mImageEventMap.erase(i);
371                 }
372
373         }
374   }
375
376   //====================================================================
377
378   //====================================================================
379   void GimmickView::ConnectValidationObserver(ValidationCallbackType callback)
380   {
381     mValidationSignal.connect(callback);
382   }
383           
384   
385 } // EO namespace creaImageIO
386
387