src/creaImageIOGimmickView.cpp

   1 #include <creaImageIOGimmickView.h>
   2 #include <creaImageIOSystem.h>
   3 #include "boost/filesystem.hpp"
   4
   5 #if defined(USE_GDCM)
   6 #include <gdcmGlobal.h>
   7 #include <gdcmSerieHelper.h>
   8 #include <vtkGdcmReader.h>
   9 #endif
  10
  11 #if defined(USE_GDCM2)
  12 #include <vtkGDCMImageReader.h>
  13 #endif
  14
  15
  16 namespace fs = boost::filesystem;
  17 namespace creaImageIO
  18 {
  19
  20         ///Class used to represent the actual state of the image selected and to perform comparisons on its values
  21   class ImageExtent
  22   {
  23   public:
  24     ImageExtent(const std::string& x, const std::string& y, const std::string& z, const std::string& t)
  25         {
  26                  sscanf(x.c_str(),"%d",&mExtent[0]);
  27                  sscanf(y.c_str(),"%d",&mExtent[1]);
  28                  sscanf(z.c_str(),"%d",&mExtent[2]);
  29                  sscanf(t.c_str(),"%d",&mExtent[3]);
  30                  if(x==""){mExtent[0]=1;}
  31              if(y==""){mExtent[1]=1;}
  32              if(z==""){mExtent[2]=1;}
  33                  if(t==""){mExtent[3]=1;}
  34
  35                  if (mExtent[3]>1) mDim=4;
  36                  else if (mExtent[2]>1) mDim=3;
  37              else if (mExtent[1]>1) mDim=2;
  38              else if (mExtent[0]>1) mDim=1;
  39                  else mDim=0;
  40         }
  41
  42
  43         ///Clears the extent
  44     void Clear() { mExtent[0] = mExtent[1] = mExtent[2] = mExtent[3] = 1; }
  45
  46         ///Returns true if the two extents are compatible
  47     bool IsCompatible( const ImageExtent& );
  48
  49         ///Adds the extent passed as a parameter to the current extent
  50     void Add ( const ImageExtent& );
  51
  52         ///Returns the ieth position of the extent
  53     int Get(int i) { return mExtent[i]; }
  54
  55         ///Returns the dimension of the current image
  56     void SetDimension(int dim) { mDim=dim; }
  57
  58         ///Returns the dimension of the current image
  59     int GetDimension() { return mDim; }
  60
  61   private:
  62     int mExtent[4];
  63     int mDim;
  64   };
  65
  66   //======================================================================
  67
  68   //======================================================================
  69   // CTor
  70   GimmickView::GimmickView(boost::shared_ptr<Gimmick> gimmick, int threads)
  71     : mGimmick(gimmick),
  72           mReader(threads)
  73   {
  74     GimmickDebugMessage(1,"GimmickView::GimmickView"
  75                         <<std::endl);
  76         // Anciently started the threads ...
  77     // Threads now automatically start at first image request
  78     //mReader.Start();
  79
  80   }
  81   //======================================================================
  82
  83   //======================================================================
  84   /// Destructor
  85   GimmickView::~GimmickView()
  86   {
  87     GimmickDebugMessage(1,"GimmickView::~GimmickView"
  88                         <<std::endl);
  89   }
  90    //======================================================================
  91
  92   //======================================================================
  93   /// Initializes the view :
  94   /// Creates the TreeViews for all the TreeHandler of the Controller
  95   ///
  96   void GimmickView::Initialize()
  97   {
  98         mReaderStarted=false;
  99   }
 100   //======================================================================
 101
 102   //======================================================================
 103   /// Finalize
 104   void GimmickView::Finalize()
 105   {
 106   }
 107
 108   //======================================================================
 109
 110   //======================================================================
 111   /// Create the tree views
 112   void GimmickView::CreateTreeViews()
 113   {
 114     GimmickMessage(2,"Creating the tree views"<<std::endl);
 115     Gimmick::TreeHandlerMapType::const_iterator i;
 116     for (i = mGimmick->GetTreeHandlerMap().begin();
 117          i!= mGimmick->GetTreeHandlerMap().end();
 118          ++i)
 119       {
 120         this->CreateTreeView(i->second);
 121       }
 122   }
 123
 124   /// Create a tree view with a given name
 125   void GimmickView::CreateSingleTreeView(std::string &i_name)
 126   {
 127         this->CreateTreeView(mGimmick->GetTreeHandlerMap()[i_name]);
 128
 129   }
 130
 131
 132   //======================================================================
 133
 134   //======================================================================
 135   /// Updates the TreeView of given name from level l to bottom
 136   /// (calls the virtual method TreeView::Update())
 137   void GimmickView::UpdateTreeViewLevel(const std::string& t, int l)
 138   {
 139     TreeViewMapType::iterator i;
 140     i = GetTreeViewMap().find(t);
 141     if ( i == GetTreeViewMap().end() )
 142       {
 143         GimmickError("INTERNAL ERROR : GimmickView::UpdateTreeView : '"
 144                      <<t<<"' is not in TreeViewMap");
 145       }
 146     i->second->UpdateLevel(l);
 147   }
 148
 149   //======================================================================
 150   /// Clears the status and begins a new selection process
 151   void GimmickView::ResetExtent()
 152   {
 153           if(mImageExtent!=0)
 154           {
 155                   mImageExtent.reset();
 156           }
 157           valid=true;
 158   }
 159
 160   //======================================================================
 161
 162   //======================================================================
 163   bool ImageExtent::IsCompatible(const ImageExtent& ie)
 164   {
 165           bool compatible=true;
 166           ImageExtent * extent= (ImageExtent*)&ie;
 167           if((*extent).Get(0)!=Get(0)
 168                  || (*extent).Get(1)!=Get(1))
 169           {
 170                   compatible=false;
 171           }
 172           return compatible;
 173   }
 174
 175   //======================================================================
 176
 177   //======================================================================
 178   void ImageExtent::Add(const ImageExtent& ie)
 179   {
 180           ImageExtent * extent= (ImageExtent*)&ie;
 181           mExtent[2]+=(*extent).Get(2);
 182           if(mExtent[2]>1)
 183           {
 184           SetDimension(3);
 185           }
 186   }
 187
 188   //======================================================================
 189   /// No selected image
 190   bool GimmickView::NoValidateSelected ()
 191   {
 192         GimmickDebugMessage(2,"Validating selected"<<std::endl);
 193         std::string mMessage;
 194         mMessage="Cannot have 0 images selected!";
 195         valid=false;
 196         modifyValidationSignal(valid);
 197         SetMessage(mMessage);
 198         return valid;
 199   }
 200
 201   //======================================================================
 202   ///Validates the dimension compliance of the images with the maximum and
 203   ///minimum given, and between their sizes
 204   bool GimmickView::ValidateSelected (tree::Node* sel, int min_dim, int max_dim)
 205   {
 206         GimmickDebugMessage(2,"Validating selected"<<std::endl);
 207         std::string mMessage;
 208
 209         if(sel==0)
 210         {
 211                 mMessage="Cannot have 0 images selected!";
 212                 valid=false;
 213         }
 214         else
 215         {
 216                 boost::shared_ptr<ImageExtent> ie=boost::shared_ptr<ImageExtent>(new ImageExtent((*sel).GetAttribute("D0028_0010"),
 217                                                                         (*sel).GetAttribute("D0028_0011"),
 218                                                                         (*sel).GetAttribute("D0028_0012"),
 219                                                                         ""));
 220         if(mImageExtent==0)
 221         {
 222                 mImageExtent=ie;
 223                 if((mImageExtent->Get(min_dim-1)<2)||(mImageExtent->Get(max_dim)>1))
 224                 {
 225                         valid=false;
 226                 }
 227                 else
 228                 {
 229                         std::stringstream out;
 230                         out << mImageExtent->GetDimension() << "D image " << mImageExtent->Get(0) << "x"<< mImageExtent->Get(1) << "x"<< mImageExtent->Get(2) <<" selected";
 231                         mMessage = out.str();
 232                         mImageExtent->SetDimension(2);
 233                         valid=true;
 234                 }
 235         }
 236         else
 237         {
 238                 if(mImageExtent->IsCompatible(*ie))
 239                 {
 240                         if(mImageExtent->GetDimension()==max_dim && mImageExtent->Get(max_dim)>2)
 241                         {
 242                                 std::stringstream out;
 243                                 out<<"Cannot add this image to selection : would result in a "<<mImageExtent->GetDimension()+1<<"D image!";
 244                                 mMessage=out.str();
 245                                 valid=false;
 246                         }
 247                         else if(max_dim<3)
 248                         {
 249                                 std::stringstream out;
 250                                 out<<"Selecting "<<mImageExtent->GetDimension()<<"D images is not allowed !";
 251                                 mMessage=out.str();
 252                                 valid=false;
 253                         }
 254                         else if(min_dim==3 && (ie->Get(2)+mImageExtent->Get(2))<2)
 255                         {
 256                                 std::stringstream out;
 257                                 out << "Cannot build the selection as it would result in a ";
 258                                 out << mImageExtent->GetDimension();
 259                                 out << "D image, and the minimum is ";
 260                                 out << min_dim;
 261                                 out << "D!";
 262                                 mMessage=out.str();
 263                                 valid=false;
 264                         }
 265                         else
 266                         {
 267                                 mImageExtent->Add(*ie);
 268                                 std::stringstream out;
 269                                 out << mImageExtent->GetDimension() << "D image " << mImageExtent->Get(0) << "x"<< mImageExtent->Get(1) << "x"<< mImageExtent->Get(2) <<" selected";
 270                                 mMessage = out.str();
 271                         }
 272                 }
 273                 else
 274                 {
 275                         mMessage="The selected images are not compatible.";
 276                         valid=false;
 277                 }
 278           }
 279         }
 280
 281         modifyValidationSignal(valid);
 282         SetMessage(mMessage);
 283         return valid;
 284   }
 285
 286   //======================================================================
 287   void GimmickView::modifyValidationSignal(bool ivalid)
 288   {
 289           mValidationSignal(ivalid);
 290   }
 291
 292    //======================================================================
 293   ///Reads Images (Non Threaded)
 294 void GimmickView::ReadImagesNotThreaded(std::vector<vtkImageData*>& s, std::vector<std::string> im, int dimension)
 295 {
 296         mReader.Stop();
 297 /* remember!
 298
 299 #define GIMMICK_NO_IMAGE_SELECTION 0
 300 #define GIMMICK_2D_IMAGE_SELECTION 2
 301 #define GIMMICK_3D_IMAGE_SELECTION 3
 302 #define GIMMICK_4D_IMAGE_SELECTION 4
 303
 304 #define NATIVE 0
 305 #define _2D    2
 306 #define _3D    3
 307
 308 */
 309         // Create the output data
 310         if (im.size()==1)
 311         {
 312                 vtkImageData * out=vtkImageData::New();
 313                 out->ShallowCopy(mReader.GetImage(im.front()));
 314                 s.push_back(out);
 315         }
 316     else if (im.size()>1) // Test inutile ? JPR
 317         {
 318                 vtkImageData* first = mReader.GetImage( im.front());
 319                 if (dimension == 2)
 320                 {
 321                  // n3D
 322                     std::vector<std::string>::iterator it;
 323                         for (it=im.begin(); it!=im.end(); ++it)
 324                         {
 325                                 vtkImageData* out = vtkImageData::New();
 326                                 out->ShallowCopy(mReader.GetImage(*it));
 327                                 s.push_back(out);
 328                         }
 329                 }
 330                 else
 331                 {
 332                         // n*2D to 3D
 333                         vtkImageData* out = vtkImageData::New();
 334 //                      out->CopyStructure(first);
 335                         out->SetScalarType(first->GetScalarType());
 336                         out->SetNumberOfScalarComponents(first->GetNumberOfScalarComponents());
 337                         int ext[6];
 338                         //first->GetExtent(ext);  // JPR
 339                         first->GetWholeExtent(ext);  // renvoie egalement 0,0 en Z // JPR
 340
 341                         if(ext[5] == 0)
 342                         {
 343                                 ext[5] = im.size()-1;
 344                         }
 345                         else
 346                         {
 347                                 ext[5] = ext[5] * im.size()-1; // to deal with multiframes - JPR
 348                         }
 349                         out->SetExtent(ext);
 350
 351                         // LG : TODO : Z Spacing  ?
 352
 353                         int dim[3];
 354                         first->GetDimensions(dim);
 355
 356                         out->SetDimensions(dim[0], dim[1], im.size() );
 357                         out->AllocateScalars();
 358                         out->Update();
 359
 360                         unsigned long imsize = dim[0] * dim[1];
 361                         imsize = imsize * dim[2] ;  // deal with multiframes // JPR
 362
 363
 364 //EED 03-11-2009
 365                         // differents formats char , short, etc...
 366                         // differents components 1..3  ex. jpg ->RGB 3
 367                         imsize = imsize * first->GetScalarSize() * first->GetNumberOfScalarComponents();
 368
 369
 370                         // Order the file name vector
 371
 372                         double spc[3];
 373                         first->GetSpacing(spc);
 374                         spc[2]=OrderTheFileNameVector(im);
 375
 376                         out->SetSpacing(spc);
 377
 378                         int slice = 0;
 379                         std::vector<std::string>::iterator it;
 380
 381                         for (it=im.begin(); it!=im.end(); ++it)
 382                         {
 383                                 vtkImageData* cur = mReader.GetImage( (*it) );
 384                                 memcpy(out->GetScalarPointer(0,0,slice), cur->GetScalarPointer(0,0,0), imsize);
 385                                 slice++;
 386                         }
 387                         s.push_back(out);
 388
 389                 }  // dimension == 3
 390
 391         }  // size >1
 392
 393 }
 394   //======================================================================
 395
 396 #if defined(USE_GDCM)
 397         double GimmickView::OrderTheFileNameVector(std::vector<std::string> &im)
 398 {
 399         double spacing=1;
 400         typedef std::vector<GDCM_NAME_SPACE::File* > FileList;
 401         FileList fileVector;
 402         //GDCM_NAME_SPACE::File *f = GDCM_NAME_SPACE::File::New();
 403         GDCM_NAME_SPACE::SerieHelper *sh = GDCM_NAME_SPACE::SerieHelper::New();
 404         std::vector<std::string> lstAux;
 405         std::vector<std::string>::iterator it;
 406         for (it=im.begin(); it!=im.end(); ++it)
 407         {
 408                 ///\TODO liberer les GDCM_NAME_SPACE::File a la fin!  // JPR
 409                 GDCM_NAME_SPACE::File *f = GDCM_NAME_SPACE::File::New();
 410                 f->SetFileName(*it);
 411                 f->Load();
 412                 if (f->IsReadable())
 413                 {
 414                         fileVector.push_back(f);
 415                 } else {
 416                         lstAux.push_back(*it);
 417                 }
 418         } // for
 419
 420
 421         if ((fileVector.size()>1) && (sh->IsCoherent( &fileVector )))
 422         {
 423                         sh->OrderFileList(&fileVector);
 424                         spacing= sh->GetZSpacing();
 425                         im.clear();
 426                         int i;
 427                         for (i=0; i<fileVector.size(); i++)
 428                         {
 429                                 im.push_back( (fileVector[i])->GetFileName() );
 430                         }
 431                         for (i=0; i<lstAux.size(); i++)
 432                         {
 433                                 im.push_back( lstAux[i] );
 434                         }
 435         }else {
 436                 std::sort( im.begin(), im.end() );
 437         }
 438
 439    return spacing;
 440 }
 441
 442
 443 #endif
 444
 445 #if defined(USE_GDCM2)
 446         // TO DO
 447         double GimmickView::OrderTheFileNameVector(std::vector<std::string> &im)
 448         {
 449                 return 1;
 450         }
 451 #endif
 452 //======================================================================
 453
 454
 455 void GimmickView::ReadImagesNotThreadedInVector(std::vector<vtkImageData*>& s, std::vector<std::string> im, int dimension)
 456 {
 457         // Create the output data
 458         if (im.size()==1)
 459         {
 460                 // Only one image : give it
 461                 vtkImageData* out = vtkImageData::New();
 462                 GimmickDebugMessage(3, "State Check: Full Filename: "
 463                                                 <<im.front()
 464                                                 <<std::endl);
 465                 out->ShallowCopy(mReader.GetImage(im.front()));
 466                 s.push_back( out );
 467         }
 468         else if (im.size()>1) // Test inutile ? JPR
 469         {
 470                 vtkImageData* first = mReader.GetImage( im.front());
 471                 if (dimension == 2)
 472                 {
 473                  // n3D
 474                   std::vector<std::string>::iterator it;
 475                         for (it=im.begin(); it!=im.end(); ++it)
 476                         {
 477                                 vtkImageData* out = vtkImageData::New();
 478                                 out->ShallowCopy(mReader.GetImage(*it));
 479                                 s.push_back(out);
 480                         }
 481                 }
 482                 else
 483                 {
 484                         // n2D to 3D // NO!
 485                         // n *2D + T in a vector :
 486
 487                         std::vector<std::string>::iterator it;
 488                         for (it=im.begin(); it!=im.end(); ++it)
 489                         {
 490                                 vtkImageData* out = mReader.GetImage( (*it));
 491                                 s.push_back(out);
 492                         }
 493                 }
 494         }
 495 }
 496   //======================================================================
 497
 498   //======================================================================
 499   ///Requests the reading of an image
 500   void GimmickView::RequestReading(tree::Node* n,
 501           int prio, int selection_index, boost::shared_ptr<ImagePointerHolder> p)
 502   {
 503           if(!mReaderStarted)
 504           {
 505                 mReader.Start();
 506                 mReaderStarted=true;
 507           }
 508     ImageEventType t(n,selection_index);
 509         t.pointerHolder = p;
 510     mImageEventMap[n->GetAttribute("FullFileName")] = t;
 511     mReader.Request(this,n->GetAttribute("FullFileName"),prio);
 512   }
 513   //======================================================================
 514
 515   //======================================================================
 516   void GimmickView::
 517   OnMultiThreadImageReaderEvent(const std::string& filename,
 518                                 MultiThreadImageReaderUser::EventType e,
 519                                 vtkImageData* image)
 520   {
 521     GimmickDebugMessage(7,
 522                         "MultiThreadImageReader event : "<<e<<std::endl);
 523         if (e==ImageLoaded)
 524         {
 525                 if (filename.size()==0)
 526                 {
 527                   //What to do in this case?
 528                   /*
 529                         GimmickDebugMessage(5,
 530                                         "Pushing unknown image in queue"
 531                                         <<std::endl);
 532                         mImageEventQueue.push_back(ImageEventType(image));*/
 533                         return;
 534                 }
 535                 ImageEventTypeMap::iterator i;
 536 //JCP 22-06-2009, test mImageEventMap.size() > 0
 537                 if(mImageEventMap.size()>0){
 538                         i = mImageEventMap.find(filename);
 539                         if (i!=mImageEventMap.end())
 540                         {
 541                                 GimmickDebugMessage(5,
 542                                                 "Putting image of file '"<<filename<<"' on pointer"
 543                                                 <<std::endl);
 544                                 ImageEventType ie(i->second);
 545                                 ie.image = image;
 546                                 ie.pointerHolder->Set(ie.image);
 547                                 //mImageEventMap.erase(i);
 548                         }
 549                 }
 550         }
 551         else if (e==Error)
 552         {
 553                 std::string mess="ERROR: MultiThreadImageReader: Cannot read image in file ";
 554                 mess+=filename;
 555                 mess+="\n";
 556                 GimmickMessage(1,mess);
 557                 ImageEventTypeMap::iterator i;
 558                 i = mImageEventMap.find(filename);
 559                 if (i!=mImageEventMap.end())
 560                 {
 561                 ImageEventType ie(i->second);
 562                 ie.image = image;
 563                 ie.pointerHolder->Set(GetDefaultImage());
 564                 //mImageEventMap.erase(i);
 565                 }
 566         }
 567
 568         else if (e==ImageUnloaded)
 569         {
 570                 std::string mess="Unloaded image in file ";
 571                 mess+=filename;
 572                 mess+="\n";
 573                 GimmickMessage(1,mess);
 574                                 ImageEventTypeMap::iterator i;
 575                 i = mImageEventMap.find(filename);
 576                 if (i!=mImageEventMap.end())
 577                 {
 578                 ImageEventType ie(i->second);
 579                 ie.image = image;
 580                 ie.pointerHolder->Set(GetDefaultImage());
 581                 //mImageEventMap.erase(i);
 582                 }
 583         }
 584   }
 585
 586   //====================================================================
 587
 588   //====================================================================
 589   void GimmickView::ConnectValidationObserver(ValidationCallbackType callback)
 590   {
 591     mValidationSignal.connect(callback);
 592   }
 593
 594 } // EO namespace creaImageIO
 595
 596 //////////////////////////////////////////////////////////////////////
 597 //void GimmickView::Anonymize(std::vector<std::string> i_filenames, int type)
 598 //      {
 599                 //if(type == 0)
 600                 //{
 601                 //   // Get private key/certificate
 602          //    gdcm::CryptographicMessageSyntax cms;
 603                 //if( !dumb_mode )
 604   //  {
 605   //  if( !GetRSAKeys(cms, rsa_path.c_str(), cert_path.c_str() ) )
 606   //    {
 607   //    return 1;
 608   //    }
 609   //  cms.SetCipherType( ciphertype );
 610   //  }
 611
 612   //// Setup gdcm::Anonymizer
 613   //gdcm::Anonymizer anon;
 614   //if( !dumb_mode )
 615   //  anon.SetCryptographicMessageSyntax( &cms );
 616
 617   //if( dumb_mode )
 618   //  {
 619   //  for(unsigned int i = 0; i < nfiles; ++i)
 620   //    {
 621   //    const char *in  = filenames[i].c_str();
 622   //    const char *out = outfilenames[i].c_str();
 623   //    if( !AnonymizeOneFileDumb(anon, in, out, empty_tags, remove_tags, replace_tags_value) )
 624   //      {
 625   //      //std::cerr << "Could not anonymize: " << in << std::endl;
 626   //      return 1;
 627   //      }
 628   //    }
 629   //  }
 630   //else
 631   //  {
 632   //  for(unsigned int i = 0; i < nfiles; ++i)
 633   //    {
 634   //    const char *in  = filenames[i].c_str();
 635   //    const char *out = outfilenames[i].c_str();
 636   //    if( !AnonymizeOneFile(anon, in, out) )
 637   //      {
 638   //      //std::cerr << "Could not anonymize: " << in << std::endl;
 639   //      return 1;
 640   //      }
 641   //    }
 642   //  }
 643 //      }