Merge branch 'master' of tux.creatis.insa-lyon.fr:clitk

diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index 4dcf32530b2d6ab661d0420b543f248d50de8ec1..91f53e5f5dcabe35d3f3011ab3175dfa1a429429 100644 (file)
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -37,6 +37,8 @@ IF(CLITK_PRIVATE_FEATURES)
   SET(clitkCommon_SRC ${clitkCommon_SRC}
     ${PROJECT_SOURCE_DIR}/private_features/clitkUsfImageIO.cxx
     ${PROJECT_SOURCE_DIR}/private_features/clitkUsfImageIOFactory.cxx
+    ${PROJECT_SOURCE_DIR}/private_features/clitkUSVoxImageIO.cxx
+    ${PROJECT_SOURCE_DIR}/private_features/clitkUSVoxImageIOFactory.cxx
     )
 ENDIF(CLITK_PRIVATE_FEATURES)
 

diff --git a/common/clitkIO.cxx b/common/clitkIO.cxx
index 011147d868fedb67d05b17cd3ec5ac15ec1b6135..cfa8e86ff994fa59492f9d95064a2cf7cc9c4a98 100644 (file)
--- a/common/clitkIO.cxx
+++ b/common/clitkIO.cxx
@@ -36,6 +36,7 @@
 #include "clitkConfiguration.h"
 #if CLITK_PRIVATE_FEATURES
   #include "clitkUsfImageIOFactory.h"
+  #include "clitkUSVoxImageIOFactory.h"
 #endif
 
 //--------------------------------------------------------------------
@@ -44,6 +45,7 @@ void clitk::RegisterClitkFactories()
 {
 #if CLITK_PRIVATE_FEATURES
   clitk::UsfImageIOFactory::RegisterOneFactory();
+  clitk::USVoxImageIOFactory::RegisterOneFactory();
 #endif
   clitk::GateAsciiImageIOFactory::RegisterOneFactory();
   clitk::DicomRTDoseIOFactory::RegisterOneFactory();

diff --git a/common/vvImage.cxx b/common/vvImage.cxx
index 0bddb262cb7a4f8ce70d204d8be1750e3ae35f0c..31c6ef0fecd8234ecde506d542a8884b2293e84b 100644 (file)
--- a/common/vvImage.cxx
+++ b/common/vvImage.cxx
@@ -32,7 +32,7 @@
 #include <cassert>
 
 //--------------------------------------------------------------------
-vvImage::vvImage():mTransform(vtkSmartPointer<vtkTransform>::New())
+vvImage::vvImage()
 {
   Init();
 }
@@ -251,7 +251,7 @@ bool vvImage::IsScalarTypeInteger(int t)
 //--------------------------------------------------------------------
 
 //--------------------------------------------------------------------
-vtkSmartPointer<vtkTransform> vvImage::GetTransform()
+const std::vector< vtkSmartPointer<vtkTransform> >& vvImage::GetTransform()
 {
   return this->mTransform;
 }

diff --git a/common/vvImage.h b/common/vvImage.h
index ec01a1ffbe40d67f0f8b6a095f8cd56a80edacef..a120457f6f9f5a5f375f22cd426f5262cf05af9e 100644 (file)
--- a/common/vvImage.h
+++ b/common/vvImage.h
@@ -56,7 +56,7 @@ public :
   bool IsTimeSequence() const;
   bool IsScalarTypeInteger();
   bool IsScalarTypeInteger(int t);
-  vtkSmartPointer<vtkTransform> GetTransform();
+  const std::vector< vtkSmartPointer<vtkTransform> >& GetTransform();
   void SetTimeSpacing(double s) { mTimeSpacing = s; }
   void SetTimeOrigin(double o) { mTimeOrigin = o; }
   bool HaveSameSizeAndSpacingThan(vvImage * other);
@@ -66,8 +66,8 @@ private:
   ~vvImage();
 
   std::vector< ConverterPointer > mItkToVtkConverters;
-  std::vector<vtkImageData*> mVtkImages;
-  vtkSmartPointer<vtkTransform> mTransform;
+  std::vector< vtkImageData* > mVtkImages;
+  std::vector< vtkSmartPointer<vtkTransform> > mTransform;
 
   double mTimeOrigin;
   double mTimeSpacing;

diff --git a/common/vvImage.txx b/common/vvImage.txx
index 14da10a227f7d825cde021a143b8c2f84a74d7bb..55b785fb4814571fd4c0a7788699d03c848b937f 100644 (file)
--- a/common/vvImage.txx
+++ b/common/vvImage.txx
@@ -50,7 +50,8 @@ void vvImage::AddItkImage(TItkImageType *input)
   // GetDirection provides the forward transform, vtkImageReslice wants the inverse
   matrix->Invert();
 
-  mTransform->SetMatrix(matrix);
+  mTransform.push_back(vtkSmartPointer<vtkTransform>::New());
+  mTransform.back()->SetMatrix(matrix);
 }
 //--------------------------------------------------------------------
 

diff --git a/common/vvImageReader.cxx b/common/vvImageReader.cxx
index 0205355f6fafc40acd2dc82984ce11f1412dddc4..c795cd9299697c7a34c784c1973541c7012e777d 100644 (file)
--- a/common/vvImageReader.cxx
+++ b/common/vvImageReader.cxx
@@ -110,37 +110,37 @@ void vvImageReader::SetInputFilenames(const std::vector<std::string> & filenames
 
 //------------------------------------------------------------------------------
 //Read transformation in NKI format (Xdr, transposed, cm)
-void vvImageReader::ReadNkiImageTransform()
-{
-  bool bRead=false;
-  std::string filename = mInputFilenames[0]+".MACHINEORIENTATION";
-  if(itksys::SystemTools::FileExists(filename.c_str())){
-    typedef itk::ImageFileReader< itk::Image< double, 2 > > MatrixReaderType;
-    MatrixReaderType::Pointer readerTransfo = MatrixReaderType::New();
-    readerTransfo->SetFileName(filename);
-    try {
-      bRead = true;
-      readerTransfo->Update();
-    } catch( itk::ExceptionObject & err ) {
-      bRead=false;
-      std::cerr << "Cannot read " << filename << std::endl
-                << "The error is: " << err << std::endl;
-    }
-
-    if (bRead) {
-      //Transpose matrix (NKI format)
-      for(int j=0; j<4; j++)
-        for(int i=0; i<4; i++)
-          mImage->GetTransform()->GetMatrix()->SetElement(j,i,readerTransfo->GetOutput()->GetBufferPointer()[4*i+j]);
-
-      //From cm to mm
-      for(int i=0; i<3; i++)
-        mImage->GetTransform()->GetMatrix()->SetElement(i,3,10*mImage->GetTransform()->GetMatrix()->GetElement(i,3));
-
-      mImage->GetTransform()->Inverse();
-    }
-  }
-}
+//void vvImageReader::ReadNkiImageTransform()
+//{
+//  bool bRead=false;
+//  std::string filename = mInputFilenames[0]+".MACHINEORIENTATION";
+//  if(itksys::SystemTools::FileExists(filename.c_str())){
+//    typedef itk::ImageFileReader< itk::Image< double, 2 > > MatrixReaderType;
+//    MatrixReaderType::Pointer readerTransfo = MatrixReaderType::New();
+//    readerTransfo->SetFileName(filename);
+//    try {
+//      bRead = true;
+//      readerTransfo->Update();
+//    } catch( itk::ExceptionObject & err ) {
+//      bRead=false;
+//      std::cerr << "Cannot read " << filename << std::endl
+//                << "The error is: " << err << std::endl;
+//    }
+
+//    if (bRead) {
+//      //Transpose matrix (NKI format)
+//      for(int j=0; j<4; j++)
+//        for(int i=0; i<4; i++)
+//          mImage->GetTransform()->GetMatrix()->SetElement(j,i,readerTransfo->GetOutput()->GetBufferPointer()[4*i+j]);
+
+//      //From cm to mm
+//      for(int i=0; i<3; i++)
+//        mImage->GetTransform()->GetMatrix()->SetElement(i,3,10*mImage->GetTransform()->GetMatrix()->GetElement(i,3));
+
+//      mImage->GetTransform()->Inverse();
+//    }
+//  }
+//}
 //------------------------------------------------------------------------------
 
 
@@ -192,9 +192,10 @@ void vvImageReader::ReadMatImageTransform()
       vtkGenericWarningMacro("Matrix in " << filename.c_str() << " cannot be inverted (determinant = 0)");
     }
 
-    mImage->GetTransform()->PostMultiply();
-    mImage->GetTransform()->Concatenate(matrix);
-    mImage->GetTransform()->Update();
+    // TODO SR and BP: check on the list of transforms and not the first only
+    mImage->GetTransform()[0]->PostMultiply();
+    mImage->GetTransform()[0]->Concatenate(matrix);
+    mImage->GetTransform()[0]->Update();
   }
 }
 //------------------------------------------------------------------------------

diff --git a/common/vvImageReader.h b/common/vvImageReader.h
index dae05e47047ec4d9fb335491b03645b9588560f0..4348e0fac7e131f38aca7ab3d1ccb47d7851902b 100644 (file)
--- a/common/vvImageReader.h
+++ b/common/vvImageReader.h
@@ -92,7 +92,7 @@ protected:
   std::string mInputPixelType;
 
   //====================================================================
-  void ReadNkiImageTransform();
+//  void ReadNkiImageTransform();
   void ReadMatImageTransform();
 private:
   vvImageReader();

diff --git a/common/vvImageReader.txx b/common/vvImageReader.txx
index 6a4333ff3c59c055c704117954747e7f656a133b..9b0e21ae6c17f8fd498008272c53fa84a9aaaa5c 100644 (file)
--- a/common/vvImageReader.txx
+++ b/common/vvImageReader.txx
@@ -187,12 +187,13 @@ void vvImageReader::UpdateWithDimAndInputPixelType()
                           0.,0.,1.,0.,
                           0.,-1.,0.,0.,
                           0.,0.,0.,1.};
+    // TODO SR and BP: check on the list of transforms and not the first only
     int i;
-    for(i=0; i<16 && m[i]==mImage->GetTransform()->GetMatrix()->GetElement(i%4, i/4); i++);
+    for(i=0; i<16 && m[i]==mImage->GetTransform()[0]->GetMatrix()->GetElement(i%4, i/4); i++);
     if(i==16) {
       itkWarningMacro(<< "Analyze image file format detected with unknown orientation. "
                       << "Forcing identity orientation, use other file format if not ok.");
-      mImage->GetTransform()->Identity();
+      mImage->GetTransform()[0]->Identity();
     }
   }
 }
@@ -259,13 +260,13 @@ void vvImageReader::UpdateWithDimAndInputVectorPixelType()
                           0.,-1.,0.,0.,
                           0.,0.,0.,1.};
     int i;
-    for (i = 0; i < 16 && m[i] == mImage->GetTransform()->GetMatrix()->GetElement(i % 4, i / 4); i++)
+    for (i = 0; i < 16 && m[i] == mImage->GetTransform()[0]->GetMatrix()->GetElement(i % 4, i / 4); i++)
       ;
     if (i == 16)
     {
       itkWarningMacro(<< "Analyze image file format detected with unknown orientation. "
                       << "Forcing identity orientation, use other file format if not ok.");
-      mImage->GetTransform()->Identity();
+      mImage->GetTransform()[0]->Identity();
     }
   }
 }

diff --git a/common/vvImageWriter.txx b/common/vvImageWriter.txx
index 0640f0cd3645bd3d036facd374f6949225718d5d..0705197fd49b4f4d1394eb864c2175e2681464f2 100644 (file)
--- a/common/vvImageWriter.txx
+++ b/common/vvImageWriter.txx
@@ -73,7 +73,8 @@ void vvImageWriter::UpdateWithDimAndOutputPixelType()
     itk::Matrix<double, 4, 4> trans;
     for(int i=0; i<4; i++)
       for(int j=0; j<4; j++)
-        trans[i][j] = mImage->GetTransform()->GetMatrix()->GetElement(i,j);
+        // TODO SR and BP: check on the list of transforms and not the first only
+        trans[i][j] = mImage->GetTransform()[0]->GetMatrix()->GetElement(i,j);
     trans = trans.GetInverse();
 
     // Direction

diff --git a/vv/qt_ui/vvMainWindow.ui b/vv/qt_ui/vvMainWindow.ui
index 789e59f3564050deb3418e0c1ba28f97b320ee8e..8d3d8ff90806dbd4810e7a111be8650f0dd300ea 100644 (file)
--- a/vv/qt_ui/vvMainWindow.ui
+++ b/vv/qt_ui/vvMainWindow.ui
@@ -67,19 +67,6 @@
        <property name="spacing">
         <number>2</number>
        </property>
-       <item row="0" column="17">
-        <spacer>
-         <property name="orientation">
-          <enum>Qt::Horizontal</enum>
-         </property>
-         <property name="sizeHint" stdset="0">
-          <size>
-           <width>40</width>
-           <height>20</height>
-          </size>
-         </property>
-        </spacer>
-       </item>
        <item row="0" column="0">
         <widget class="QPushButton" name="goToCursorPushButton">
          <property name="sizePolicy">
@@ -330,7 +317,7 @@
          </item>
         </widget>
        </item>
-       <item row="0" column="19">
+       <item row="0" column="21">
         <widget class="QPushButton" name="viewButton">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
@@ -356,13 +343,6 @@
          </property>
         </widget>
        </item>
-       <item row="0" column="18">
-        <widget class="Line" name="line_3">
-         <property name="orientation">
-          <enum>Qt::Vertical</enum>
-         </property>
-        </widget>
-       </item>
        <item row="0" column="4">
         <widget class="QSpinBox" name="frameRateSpinBox">
          <property name="minimum">
@@ -402,6 +382,40 @@
          </property>
         </widget>
        </item>
+       <item row="0" column="19">
+        <widget class="QComboBox" name="slicingPresetComboBox">
+         <item>
+          <property name="text">
+           <string>World</string>
+          </property>
+         </item>
+         <item>
+          <property name="text">
+           <string>Voxels</string>
+          </property>
+         </item>
+        </widget>
+       </item>
+       <item row="0" column="18">
+        <widget class="QLabel" name="label_2">
+         <property name="text">
+          <string>Slice to</string>
+         </property>
+        </widget>
+       </item>
+       <item row="0" column="17">
+        <spacer name="horizontalSpacer">
+         <property name="orientation">
+          <enum>Qt::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
       </layout>
      </widget>
     </item>
@@ -791,7 +805,7 @@
      <x>0</x>
      <y>0</y>
      <width>1008</width>
-     <height>22</height>
+     <height>25</height>
     </rect>
    </property>
    <property name="defaultUp">

diff --git a/vv/vv.cxx b/vv/vv.cxx
index f5029b1d6c9114a0d03d9768364eba90a14af8b4..b4beaa8dcdf7f5a18799793a3025141792fc1514 100644 (file)
--- a/vv/vv.cxx
+++ b/vv/vv.cxx
@@ -45,6 +45,9 @@
 #include <sys/stat.h>
 #include <errno.h>
 
+typedef enum {O_BASE,O_OVERLAY,O_FUSION,O_VF,O_CONTOUR} OpenModeType;
+typedef enum {P_NORMAL,P_SEQUENCE,P_WINDOW,P_LEVEL} ParseModeType;
+
 void load_image_first_error()
 {
   std::cerr << "You need to load an image before adding an overlay!" << std::endl;
@@ -65,6 +68,28 @@ std::string create_timed_string()
   return st;
 }
 
+void open_sequence(vvMainWindow &window,
+                   OpenModeType &open_mode,
+                   ParseModeType &parse_mode,
+                   std::vector<std::string> &sequence_filenames,
+                   int n_image_loaded)
+{
+  const std::string open_mode_names[] = {"base", "overlay", "fusion", "vf", "contour"};
+  if(open_mode==O_BASE)
+    window.LoadImages(sequence_filenames, vvImageReader::MERGEDWITHTIME);
+  else if (open_mode==O_OVERLAY)
+    window.AddOverlayImage(n_image_loaded-1,sequence_filenames,vvImageReader::MERGEDWITHTIME);
+  else {
+    std::cerr << "Sequences are not managed for opening " << open_mode_names[open_mode] << std::endl;
+    exit(1);
+  }
+
+  // Reset
+  sequence_filenames.clear();
+  parse_mode=P_NORMAL;
+  open_mode=O_BASE;
+}
+
 //------------------------------------------------------------------------------
 #ifdef _WIN32
 int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE prevInstance, LPSTR lpCmdLine, int nShowCmd)
@@ -110,8 +135,8 @@ int main( int argc, char** argv )
   window.show();
 
   std::vector<std::string> sequence_filenames;
-  enum {P_NORMAL,P_SEQUENCE,P_WINDOW,P_LEVEL};
-  int parse_mode=P_NORMAL;
+  ParseModeType parse_mode = P_NORMAL;
+  OpenModeType open_mode = O_BASE;
   int n_image_loaded=0;
   std::string win(""), lev("");
 
@@ -121,9 +146,7 @@ int main( int argc, char** argv )
       std::string current = argv[i];
       if (!current.compare(0,1,"-")) { // && !current.compare(0,2,"--")) { //We are parsing an option
         if (parse_mode == P_SEQUENCE) {//First finish the current sequence
-          window.LoadImages(sequence_filenames, vvImageReader::MERGEDWITHTIME);
-          sequence_filenames.clear();
-          parse_mode=P_NORMAL;
+          open_sequence(window, open_mode, parse_mode, sequence_filenames, n_image_loaded);
         } 
         else if (parse_mode == P_WINDOW) { // handle negative window values
           win=current;
@@ -156,26 +179,18 @@ int main( int argc, char** argv )
           exit(0);
         } else if (current=="--vf") {
           if (!n_image_loaded) load_image_first_error();
-          window.AddField(argv[i+1],n_image_loaded-1);
-          i++; //skip vf name
+          open_mode = O_VF;
         } else if (current=="--overlay") {
           if (!n_image_loaded) load_image_first_error();
-          window.AddOverlayImage(n_image_loaded-1,argv[i+1]);
-          i++; //skip overlay name
-        } /*else if (current=="--roi") {
+          open_mode = O_OVERLAY;
+        } else if (current=="--contour") {
           if (!n_image_loaded) load_image_first_error();
-          window.AddROI(n_image_loaded-1,argv[i+1]);
-          i++; //skip roi name
-        }*/ else if (current=="--contour") {
-          if (!n_image_loaded) load_image_first_error();
-          window.AddDCStructContour(n_image_loaded-1,argv[i+1]);
-          i++; //skip roi name
+          open_mode = O_CONTOUR;
         } else if (current=="--fusion") {
           if (!n_image_loaded) load_image_first_error();
-          window.AddFusionImage(n_image_loaded-1,argv[i+1]);
-          i++; //skip fusion name
+          open_mode = O_FUSION;
         } else if (current == "--sequence") {
-          n_image_loaded++; //count only one for the sequence
+          if(open_mode==O_BASE) n_image_loaded++; //count only one for the whole sequence
           parse_mode=P_SEQUENCE;
         } else if (current == "--window") {
           parse_mode=P_WINDOW;
@@ -228,14 +243,23 @@ int main( int argc, char** argv )
       } else {
         std::vector<std::string> image;
         image.push_back(current);
-        window.LoadImages(image, vvImageReader::IMAGE);
-        n_image_loaded++;
+        if(open_mode==O_BASE) {
+          window.LoadImages(image, vvImageReader::IMAGE);
+          n_image_loaded++;
+        }
+        else if (open_mode==O_VF)
+          window.AddField(current.c_str(), n_image_loaded-1);
+        else if (open_mode==O_OVERLAY)
+          window.AddOverlayImage(n_image_loaded-1,image,vvImageReader::IMAGE);
+        else if (open_mode==O_CONTOUR)
+          window.AddDCStructContour(n_image_loaded-1,current.c_str());
+        else if (open_mode==O_FUSION)
+          window.AddFusionImage(n_image_loaded-1,current.c_str());
+        open_mode = O_BASE;
       }
     }
     if (parse_mode == P_SEQUENCE) { //Finish any current sequence
-      window.LoadImages(sequence_filenames, vvImageReader::MERGEDWITHTIME);
-      sequence_filenames.clear();
-      parse_mode=P_NORMAL;
+      open_sequence(window, open_mode, parse_mode, sequence_filenames, n_image_loaded);
     }
   }
 

diff --git a/vv/vvMainWindow.cxx b/vv/vvMainWindow.cxx
index 9fc078cb1c09dbcdd362e17cda4fbdb5b6f75eeb..8f94ff664c8bdb033e3228d57f54f4126d81b4ba 100644 (file)
--- a/vv/vvMainWindow.cxx
+++ b/vv/vvMainWindow.cxx
@@ -309,10 +309,10 @@ vvMainWindow::vvMainWindow():vvMainWindowBase()
   connect(levelSpinBox,SIGNAL(editingFinished()),this,SLOT(WindowLevelEdited()));
   connect(colorMapComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(UpdateColorMap()));
   connect(presetComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(UpdateWindowLevel()));
+  connect(slicingPresetComboBox, SIGNAL(currentIndexChanged(int)),this,SLOT(UpdateSlicingPreset()));
   connect(inverseButton,SIGNAL(clicked()),this,SLOT(SwitchWindowLevel()));
   connect(applyWindowLevelToAllButton,SIGNAL(clicked()),this,SLOT(ApplyWindowLevelToAllImages()));
 
-
   connect(this,SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(ShowContextMenu(QPoint)));
 
   connect(linkPanel,SIGNAL(addLink(QString,QString)),this,SLOT(AddLink(QString,QString)));
@@ -952,6 +952,8 @@ void vvMainWindow::LoadImages(std::vector<std::string> files, vvImageReader::Loa
                 this,SLOT(UpdateSlice(int,int)));
         connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int)),
                 this,SLOT(UpdateTSlice(int, int)));
+        connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int)),
+                this,SLOT(ImageInfoChanged()));
         connect(mSlicerManagers.back(), SIGNAL(UpdateSliceRange(int,int,int,int,int)),
                 this,SLOT(UpdateSliceRange(int,int,int,int,int)));
         connect(mSlicerManagers.back(), SIGNAL(UpdateLinkManager(std::string,int,double,double,double,int)),
@@ -1084,7 +1086,8 @@ void vvMainWindow::ImageInfoChanged()
     QString inputSizeInBytes;
     QString image = DataTree->selectedItems()[0]->data(COLUMN_IMAGE_NAME,Qt::DisplayRole).toString();
 
-    if (mSlicerManagers[index]->GetSlicer(0)->GetImage()->GetVTKImages().size() > 1 || playMode == 1) {
+    int nframes = mSlicerManagers[index]->GetSlicer(0)->GetTMax();
+    if (nframes > 1 || playMode == 1) {
       playButton->setEnabled(1);
       frameRateLabel->setEnabled(1);
       frameRateSpinBox->setEnabled(1);
@@ -1139,7 +1142,7 @@ void vvMainWindow::ImageInfoChanged()
     infoPanel->setOrigin(GetVectorDoubleAsString(origin));
     infoPanel->setSpacing(GetVectorDoubleAsString(inputSpacing));
     infoPanel->setNPixel(QString::number(NPixel)+" ("+inputSizeInBytes+")");
-    transformation = imageSelected->GetTransform()->GetMatrix();
+    transformation = imageSelected->GetTransform()[mSlicerManagers[index]->GetTSlice()]->GetMatrix();
     infoPanel->setTransformation(Get4x4MatrixDoubleAsString(transformation));
 
     landmarksPanel->SetCurrentLandmarks(mSlicerManagers[index]->GetLandmarks(),
@@ -1176,6 +1179,7 @@ void vvMainWindow::ImageInfoChanged()
       }
     }
     WindowLevelChanged();
+    slicingPresetComboBox->setCurrentIndex(mSlicerManagers[index]->GetSlicingPreset());
 
     if (mSlicerManagers[index]->GetSlicer(0)->GetVF()) {
       overlayPanel->getVFName(mSlicerManagers[index]->GetVFName().c_str());
@@ -1497,17 +1501,12 @@ void vvMainWindow::DisplaySliders(int slicer, int window)
   int tRange[2];
   tRange[0] = 0;
   tRange[1] = mSlicerManagers[slicer]->GetSlicer(window)->GetTMax();
-  int tPosition = mSlicerManagers[slicer]->GetSlicer(window)->GetTSlice();
+  int tPosition = mSlicerManagers[slicer]->GetSlicer(window)->GetMaxCurrentTSlice();
   bool showHorizontal = false;
   bool showVertical = false;
-  if (mSlicerManagers[slicer]->GetSlicer(window)->GetImage()->GetNumberOfDimensions() > 3
-      || (mSlicerManagers[slicer]->GetSlicer(window)->GetImage()->GetNumberOfDimensions() > 2
-          && mSlicerManagers[slicer]->GetType() != vvImageReader::IMAGEWITHTIME
-          && mSlicerManagers[slicer]->GetType() != vvImageReader::MERGEDWITHTIME))
+  if (range[1]>0)
     showVertical = true;
-  if (mSlicerManagers[slicer]->GetSlicer(window)->GetImage()->GetNumberOfDimensions() > 3
-      || mSlicerManagers[slicer]->GetType() == vvImageReader::IMAGEWITHTIME
-      || mSlicerManagers[slicer]->GetType() == vvImageReader::MERGEDWITHTIME)
+  if (tRange[1]>0)
     showHorizontal = true;
 
   if (showVertical)
@@ -1721,6 +1720,16 @@ void vvMainWindow::UpdateWindowLevel()
 }
 //------------------------------------------------------------------------------
 
+//------------------------------------------------------------------------------
+void vvMainWindow::UpdateSlicingPreset()
+{
+  if (DataTree->selectedItems().size()) {
+    int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
+    mSlicerManagers[index]->SetSlicingPreset(vvSlicerManager::SlicingPresetType(slicingPresetComboBox->currentIndex()));
+  }
+}
+//------------------------------------------------------------------------------
+
 //------------------------------------------------------------------------------
 void vvMainWindow::UpdateColorMap()
 {
@@ -1845,21 +1854,28 @@ void vvMainWindow::SelectOverlayImage()
 
   QString Extensions = EXTENSIONS;
   Extensions += ";;All Files (*)";
-  QString file = QFileDialog::getOpenFileName(this,tr("Load Overlay image"),mInputPathName,Extensions);
-  if (!file.isEmpty())
-    AddOverlayImage(index,file);
+  QStringList files = QFileDialog::getOpenFileNames(this,tr("Load Overlay image"),mInputPathName,Extensions);
+  if (files.isEmpty())
+    return;
+
+  std::vector<std::string> vecFileNames;
+  for (int i = 0; i < files.size(); i++) {
+    vecFileNames.push_back(files[i].toStdString());
+  }
+  AddOverlayImage(index,vecFileNames,vvImageReader::IMAGE);
 }
 //------------------------------------------------------------------------------
 
 //------------------------------------------------------------------------------
-void vvMainWindow::AddOverlayImage(int index, QString file)
+void vvMainWindow::AddOverlayImage(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type)
 {
+  QString file(fileNames[0].c_str());
   if (QFile::exists(file))
   {
     mInputPathName = itksys::SystemTools::GetFilenamePath(file.toStdString()).c_str();
     itk::ImageIOBase::Pointer reader = itk::ImageIOFactory::CreateImageIO(
         file.toStdString().c_str(), itk::ImageIOFactory::ReadMode);
-    reader->SetFileName(file.toStdString().c_str());
+    reader->SetFileName(fileNames[0].c_str());
     reader->ReadImageInformation();
     std::string component = reader->GetComponentTypeAsString(reader->GetComponentType());
     int dimension = reader->GetNumberOfDimensions();
@@ -1868,7 +1884,7 @@ void vvMainWindow::AddOverlayImage(int index, QString file)
     qApp->processEvents();
 
     std::string filename = itksys::SystemTools::GetFilenameWithoutExtension(file.toStdString()).c_str();
-    if (mSlicerManagers[index]->SetOverlay(file.toStdString(),dimension, component)) {
+    if (mSlicerManagers[index]->SetOverlay(fileNames,dimension, component,type)) {
       //create an item in the tree with good settings
       QTreeWidgetItem *item = new QTreeWidgetItem();
       item->setData(0,Qt::UserRole,file.toStdString().c_str());
@@ -1912,6 +1928,10 @@ void vvMainWindow::AddOverlayImage(int index, QString file)
       qApp->processEvents();
       ImageInfoChanged();
       QApplication::restoreOverrideCursor();
+
+      // Update the display to update, e.g., the sliders
+      for(int i=0; i<4; i++)
+        DisplaySliders(index, i);
     } else {
       QApplication::restoreOverrideCursor();
       QString error = "Cannot import the new image.\n";
@@ -2308,7 +2328,8 @@ void vvMainWindow::SaveAs()
       bool bId = true;
       for(int i=0; i<4; i++)
         for(int j=0; j<4; j++) {
-          double elt = mSlicerManagers[index]->GetImage()->GetTransform()->GetMatrix()->GetElement(i,j);
+          // TODO SR and BP: check on the list of transforms and not the first only
+          double elt = mSlicerManagers[index]->GetImage()->GetTransform()[0]->GetMatrix()->GetElement(i,j);
           if(i==j && elt!=1.)
             bId = false;
           if(i!=j && elt!=0.)
@@ -2874,9 +2895,8 @@ void vvMainWindow::SaveScreenshot(QVTKWidget *widget)
       vidwriter->SetInput(image);
       vidwriter->SetFileName(fileName.toStdString().c_str());
       vidwriter->Start();
-      vvImage * vvImg = mSlicerManagers[smIndex]->GetImage();
-      int nSlice = vvImg->GetVTKImages().size();
-      for(int i=0; i<nSlice; i++) {
+      int nSlice = mSlicerManagers[smIndex]->GetSlicer(0)->GetTMax();
+      for(int i=0; i<=nSlice; i++) {
         mSlicerManagers[smIndex]->SetNextTSlice(0);
         vtkSmartPointer<vtkWindowToImageFilter> w2i = vtkSmartPointer<vtkWindowToImageFilter>::New();
         w2i->SetInput(widget->GetRenderWindow());
@@ -2924,7 +2944,7 @@ void vvMainWindow::PlayPause()
     int image_number=DataTree->topLevelItemCount();
     bool has_temporal;
     for (int i=0; i<image_number; i++)
-      if (mSlicerManagers[i]->GetImage()->GetVTKImages().size() > 1) {
+      if (mSlicerManagers[i]->GetSlicer(0)->GetTMax() > 0) {
         has_temporal=true;
         break;
       }
@@ -2945,7 +2965,7 @@ void vvMainWindow::PlayNext()
     ///Only play one slicer per SM, and only if the SM is being displayed
     for (int i=0; i<image_number; i++)
       for (int j=0; j<4; j++)
-        if (mSlicerManagers[i]->GetImage()->GetVTKImages().size() > 1 &&
+        if (mSlicerManagers[i]->GetSlicer(0)->GetTMax() > 0 &&
             DataTree->topLevelItem(i)->data(j+1,Qt::CheckStateRole).toInt() > 0) {
           mSlicerManagers[i]->SetNextTSlice(j);
           break;
@@ -3079,6 +3099,8 @@ vvSlicerManager* vvMainWindow::AddImage(vvImage::Pointer image,std::string filen
           this,SLOT(UpdateSlice(int,int)));
   connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int)),
           this,SLOT(UpdateTSlice(int, int)));
+  connect(mSlicerManagers.back(), SIGNAL(UpdateTSlice(int, int)),
+          this,SLOT(ImageInfoChanged()));
   connect(mSlicerManagers.back(), SIGNAL(UpdateSliceRange(int,int,int,int,int)),
           this,SLOT(UpdateSliceRange(int,int,int,int,int)));
   connect(mSlicerManagers.back(), SIGNAL(UpdateLinkManager(std::string,int,double,double,double,int)),

diff --git a/vv/vvMainWindow.h b/vv/vvMainWindow.h
index bbdfe263719e83dd037b7c3d4b070834b3624262..015a468924ec6a1e9836d24aeae884352cd781b5 100644 (file)
--- a/vv/vvMainWindow.h
+++ b/vv/vvMainWindow.h
@@ -54,7 +54,7 @@ class vvMainWindow: public vvMainWindowBase,
   void LoadImages(std::vector<std::string> filenames, vvImageReader::LoadedImageType type);
   vvSlicerManager * AddImage(vvImage::Pointer image,std::string filename);
   void AddField(QString file,int index);
-  void AddOverlayImage(int index, QString filename);
+  void AddOverlayImage(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type);
   void AddFusionImage(int index, QString filename);
   void AddROI(int index, QString filename);
   ///Adds a mesh to a SlicerManager, with optional warping by vector field
@@ -118,6 +118,7 @@ public slots:
   void SetWindowLevel(double w, double l);
   void UpdateColorMap();
   void UpdateWindowLevel();
+  void UpdateSlicingPreset();
   void SwitchWindowLevel();
   void ApplyWindowLevelToAllImages();
   void UpdateLinkManager(std::string id, int slicer, double x, double y, double z, int temps);

diff --git a/vv/vvReadState.cxx b/vv/vvReadState.cxx
index 7383ecdcd30a1e311a00b431a135c5ac5efdcbc4..6d61ca5df6b8d0132fb75be64459bfe18bac46fe 100644 (file)
--- a/vv/vvReadState.cxx
+++ b/vv/vvReadState.cxx
@@ -191,8 +191,12 @@ std::string vvReadState::ReadOverlay(int index)
     if (m_XmlReader->isStartElement()) {
       if (value == "FileName") {
         file = m_XmlReader->readElementText().toStdString();
-        if (!m_XmlReader->hasError())
-          m_Window->AddOverlayImage(index, file.c_str());
+        if (!m_XmlReader->hasError()) {
+          // TODO: manage sequence of images
+          std::vector<std::string> vec;
+          vec.push_back(file.c_str());
+          m_Window->AddOverlayImage(index, vec, vvImageReader::IMAGE);
+        }
       }
       if (value == "OverlayColorWindow") {
         vald = m_XmlReader->readElementText().toDouble();

diff --git a/vv/vvSlicer.cxx b/vv/vvSlicer.cxx
index 1e133d6f863cfd8dcad8ec52fa6c02a01cbe8296..17aa41b81a9619b928a3268fea886d6d4c858fad 100644 (file)
--- a/vv/vvSlicer.cxx
+++ b/vv/vvSlicer.cxx
@@ -82,6 +82,8 @@ vvSlicer::vvSlicer()
   mImage = NULL;
   mReducedExtent = new int[6];
   mCurrentTSlice = 0;
+  mCurrentFusionTSlice = 0;
+  mCurrentOverlayTSlice = 0;
   mUseReducedExtent = false;
 
   mCurrent[0] = -VTK_DOUBLE_MAX;
@@ -145,6 +147,11 @@ vvSlicer::vvSlicer()
 #if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
   this->GetImageActor()->GetMapper()->BorderOn();
 #endif
+
+  mSlicingTransform = vtkSmartPointer<vtkTransform>::New();
+  mConcatenatedTransform = vtkSmartPointer<vtkTransform>::New();
+  mConcatenatedFusionTransform = vtkSmartPointer<vtkTransform>::New();
+  mConcatenatedOverlayTransform = vtkSmartPointer<vtkTransform>::New();
 }
 //------------------------------------------------------------------------------
 
@@ -290,14 +297,21 @@ vvSlicer::~vvSlicer()
 }
 //------------------------------------------------------------------------------
 
+//------------------------------------------------------------------------------
+double* vvSlicer::GetCurrentPosition()
+{
+  return mCurrentBeforeSlicingTransform;
+}
+//------------------------------------------------------------------------------
 
 //------------------------------------------------------------------------------
 void vvSlicer::SetCurrentPosition(double x, double y, double z, int t)
 {
-  mCurrent[0] = x;
-  mCurrent[1] = y;
-  mCurrent[2] = z;
-  mCurrentTSlice = t;
+  mCurrentBeforeSlicingTransform[0]=x;
+  mCurrentBeforeSlicingTransform[1]=y;
+  mCurrentBeforeSlicingTransform[2]=z;
+  mSlicingTransform->GetInverse()->TransformPoint(mCurrentBeforeSlicingTransform,mCurrent);
+  SetTSlice(t);
 }
 //------------------------------------------------------------------------------
 
@@ -314,7 +328,11 @@ void vvSlicer::SetImage(vvImage::Pointer image)
       mImageReslice->AutoCropOutputOn();
       mImageReslice->SetBackgroundColor(-1000,-1000,-1000,1);
     }
-    mImageReslice->SetResliceTransform(mImage->GetTransform());
+
+    mConcatenatedTransform->Identity();
+    mConcatenatedTransform->Concatenate(mImage->GetTransform()[0]);
+    mConcatenatedTransform->Concatenate(mSlicingTransform);
+    mImageReslice->SetResliceTransform(mConcatenatedTransform);
     mImageReslice->SetInput(0, mImage->GetFirstVTKImageData());
     mImageReslice->UpdateInformation();
 
@@ -355,8 +373,13 @@ void vvSlicer::SetOverlay(vvImage::Pointer overlay)
       mOverlayReslice->AutoCropOutputOn();
       mOverlayReslice->SetBackgroundColor(-1000,-1000,-1000,1);
     }
-    mOverlayReslice->SetResliceTransform(mOverlay->GetTransform());
+
+    mConcatenatedOverlayTransform->Identity();
+    mConcatenatedOverlayTransform->Concatenate(mOverlay->GetTransform()[0]);
+    mConcatenatedOverlayTransform->Concatenate(mSlicingTransform);
+    mOverlayReslice->SetResliceTransform(mConcatenatedOverlayTransform);
     mOverlayReslice->SetInput(0, mOverlay->GetFirstVTKImageData());
+    mImageReslice->UpdateInformation();
 
     if (!mOverlayMapper)
       mOverlayMapper = vtkSmartPointer<vtkImageMapToWindowLevelColors>::New();
@@ -402,8 +425,13 @@ void vvSlicer::SetFusion(vvImage::Pointer fusion)
       mFusionReslice->AutoCropOutputOn();
       mFusionReslice->SetBackgroundColor(-1000,-1000,-1000,1);
     }
-    mFusionReslice->SetResliceTransform(mFusion->GetTransform());
+
+    mConcatenatedFusionTransform->Identity();
+    mConcatenatedFusionTransform->Concatenate(mFusion->GetTransform()[0]);
+    mConcatenatedFusionTransform->Concatenate(mSlicingTransform);
+    mFusionReslice->SetResliceTransform(mConcatenatedFusionTransform);
     mFusionReslice->SetInput(0, mFusion->GetFirstVTKImageData());
+    mFusionReslice->UpdateInformation();
 
     if (!mFusionMapper)
       mFusionMapper = vtkSmartPointer<vtkImageMapToColors>::New();
@@ -680,23 +708,44 @@ void vvSlicer::SetVFLog(int log)
 void vvSlicer::SetTSlice(int t)
 {
   if (t < 0)
-    t = 0;
+    mCurrentTSlice = 0;
   else if ((unsigned int)t >= mImage->GetVTKImages().size())
-    t = mImage->GetVTKImages().size() -1;
+    mCurrentTSlice = mImage->GetVTKImages().size() -1;
+  else
+    mCurrentTSlice = t;
+
+  // Update transform
+  mConcatenatedTransform->Identity();
+  mConcatenatedTransform->Concatenate(mImage->GetTransform()[mCurrentTSlice]);
+  mConcatenatedTransform->Concatenate(mSlicingTransform);
 
-  mCurrentTSlice = t;
+  // Update image data
   mImageReslice->SetInput( mImage->GetVTKImages()[mCurrentTSlice] );
   if (mVF && mVFActor->GetVisibility()) {
     if (mVF->GetVTKImages().size() > (unsigned int)mCurrentTSlice)
       mVOIFilter->SetInput(mVF->GetVTKImages()[mCurrentTSlice]);
   }
   if (mOverlay && mOverlayActor->GetVisibility()) {
-    if (mOverlay->GetVTKImages().size() > (unsigned int)mCurrentTSlice)
-      mOverlayReslice->SetInput( mOverlay->GetVTKImages()[mCurrentTSlice] );
+    if (mOverlay->GetVTKImages().size() > (unsigned int)t) {
+      mCurrentOverlayTSlice = t;
+      mOverlayReslice->SetInput( mOverlay->GetVTKImages()[mCurrentOverlayTSlice] );
+
+      // Update overlay transform
+      mConcatenatedOverlayTransform->Identity();
+      mConcatenatedOverlayTransform->Concatenate(mOverlay->GetTransform()[mCurrentOverlayTSlice]);
+      mConcatenatedOverlayTransform->Concatenate(mSlicingTransform);
+    }
   }
   if (mFusion && mFusionActor->GetVisibility()) {
-    if (mFusion->GetVTKImages().size() > (unsigned int)mCurrentTSlice)
-      mFusionReslice->SetInput( mFusion->GetVTKImages()[mCurrentTSlice]);
+    if (mFusion->GetVTKImages().size() > (unsigned int)t) {
+      mCurrentFusionTSlice = t;
+      mFusionReslice->SetInput( mFusion->GetVTKImages()[mCurrentFusionTSlice]);
+
+      // Update fusion transform
+      mConcatenatedFusionTransform->Identity();
+      mConcatenatedFusionTransform->Concatenate(mFusion->GetTransform()[mCurrentFusionTSlice]);
+      mConcatenatedFusionTransform->Concatenate(mSlicingTransform);
+    }
   }
   if (mSurfaceCutActors.size() > 0)
     for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
@@ -714,6 +763,32 @@ int vvSlicer::GetTSlice()
 }
 //------------------------------------------------------------------------------
 
+//------------------------------------------------------------------------------
+int vvSlicer::GetMaxCurrentTSlice()
+{
+  int t = mCurrentTSlice;
+  if(mOverlay)
+    t = std::max(t, mCurrentOverlayTSlice);
+  if(mFusion)
+    t = std::max(t, mCurrentFusionTSlice);
+  return t;
+}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+int vvSlicer::GetFusionTSlice()
+{
+  return mCurrentFusionTSlice;
+}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+int vvSlicer::GetOverlayTSlice()
+{
+  return mCurrentOverlayTSlice;
+}
+//------------------------------------------------------------------------------
+
 //------------------------------------------------------------------------------
 void vvSlicer::SetSliceOrientation(int orientation)
 {
@@ -920,9 +995,8 @@ void vvSlicer::UpdateDisplayExtent()
         double cpos = (double)cam->GetPosition()[this->SliceOrientation];
         double range = fabs(spos - cpos);
         double *spacing = input->GetSpacing();
-        double avg_spacing =
-          ((double)spacing[0] + (double)spacing[1] + (double)spacing[2]) / 3.0;
-        cam->SetClippingRange(range - avg_spacing * 3.0, range + avg_spacing * 3.0);
+        double sumSpacing = spacing[0] + spacing[1] + spacing[2];
+        cam->SetClippingRange(range - sumSpacing, range + sumSpacing);
       }
     }
   }
@@ -1178,7 +1252,7 @@ void vvSlicer::SetOverlayColorLevel(double level)
 //----------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
-// Returns the min an the max value in a 41x41 region around the mouse pointer
+// Returns the min an the max value in a 20%x20% region around the mouse pointer
 void vvSlicer::GetExtremasAroundMousePointer(double & min, double & max, vtkImageData *image, vtkTransform *transform)
 {
   //Get mouse pointer position in view coordinates
@@ -1272,34 +1346,29 @@ void vvSlicer::Render()
 
   if (ca->GetVisibility()) {
     std::stringstream worldPos;
-    double X = (mCurrent[0] - this->GetInput()->GetOrigin()[0])/this->GetInput()->GetSpacing()[0];
-    double Y = (mCurrent[1] - this->GetInput()->GetOrigin()[1])/this->GetInput()->GetSpacing()[1];
-    double Z = (mCurrent[2] - this->GetInput()->GetOrigin()[2])/this->GetInput()->GetSpacing()[2];
-    
-//     if (X < this->GetInput()->GetWholeExtent()[0]) X = this->GetInput()->GetWholeExtent()[0];
-//     else if (X > this->GetInput()->GetWholeExtent()[1]) X = this->GetInput()->GetWholeExtent()[1]; 
-//     if (Y < this->GetInput()->GetWholeExtent()[2]) Y = this->GetInput()->GetWholeExtent()[2];
-//     else if (Y > this->GetInput()->GetWholeExtent()[3]) Y = this->GetInput()->GetWholeExtent()[3]; 
-//     if (Z < this->GetInput()->GetWholeExtent()[4]) Z = this->GetInput()->GetWholeExtent()[4];
-//     else if (Z > this->GetInput()->GetWholeExtent()[5]) Z = this->GetInput()->GetWholeExtent()[5]; 
-
-    if (X >= this->GetInput()->GetWholeExtent()[0] &&
-        X <= this->GetInput()->GetWholeExtent()[1] &&
-        Y >= this->GetInput()->GetWholeExtent()[2] &&
-        Y <= this->GetInput()->GetWholeExtent()[3] &&
-        Z >= this->GetInput()->GetWholeExtent()[4] &&
-        Z <= this->GetInput()->GetWholeExtent()[5]) {
+    double pt[3];
+    mConcatenatedTransform->TransformPoint(mCurrent, pt);
+    double X = (pt[0] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[0])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[0];
+    double Y = (pt[1] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[1])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[1];
+    double Z = (pt[2] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[2])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[2];
+
+    if (X >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[0]-0.5 &&
+        X <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[1]+0.5 &&
+        Y >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[2]-0.5 &&
+        Y <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[3]+0.5 &&
+        Z >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[4]-0.5 &&
+        Z <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[5]+0.5) {
 
       
       int ix, iy, iz;
-      double value = this->GetScalarComponentAsDouble(this->GetInput(), X, Y, Z, ix, iy, iz);
+      double value = this->GetScalarComponentAsDouble(mImage->GetVTKImages()[mCurrentTSlice], X, Y, Z, ix, iy, iz);
 
       if(ImageActor->GetVisibility())
         worldPos << "data value : " << value << std::endl;
 
-      worldPos << "mm : " << lrint(mCurrent[0]) << ' '
-                          << lrint(mCurrent[1]) << ' '
-                          << lrint(mCurrent[2]) << ' '
+      worldPos << "mm : " << lrint(mCurrentBeforeSlicingTransform[0]) << ' '
+                          << lrint(mCurrentBeforeSlicingTransform[1]) << ' '
+                          << lrint(mCurrentBeforeSlicingTransform[2]) << ' '
                           << mCurrentTSlice
                           << std::endl;
       worldPos << "pixel : " << ix << ' '
@@ -1411,6 +1480,14 @@ void vvSlicer::SetSlice(int slice)
 }
 //----------------------------------------------------------------------------
 
+//----------------------------------------------------------------------------
+int vvSlicer::GetTMax() {
+  int tmax = (int)mImage->GetVTKImages().size() - 1;
+  if(mOverlay)
+    tmax = std::max(tmax, (int)mOverlay->GetVTKImages().size()-1);
+  return tmax;
+}
+//----------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
 void vvSlicer::SetContourSlice()

diff --git a/vv/vvSlicer.h b/vv/vvSlicer.h
index c09001dcb38e90d66080459f0152d4ea77c80e28..9a750e14d69a6db41596d143e4d3ff30c33b9fae 100644 (file)
--- a/vv/vvSlicer.h
+++ b/vv/vvSlicer.h
@@ -99,11 +99,12 @@ public:
   void SetSliceOrientation(int orientation);
   void AdjustResliceToSliceOrientation(vtkImageReslice *reslice);
   int GetTSlice();
+  int GetFusionTSlice();
+  int GetOverlayTSlice();
+  int GetMaxCurrentTSlice();
   ///Reimplemented from vtkImageViewer2 to add polydata support
   void SetSlice(int s);
-  int GetTMax() {
-    return (unsigned int)mImage->GetVTKImages().size() - 1;
-  }
+  int GetTMax();
 
   void SetOpacity(double s);
   void SetRenderWindow(int orientation, vtkRenderWindow * rw);
@@ -140,10 +141,13 @@ public:
     return mCursor;
   }
 
+  vtkTransform * GetSlicingTransform() { return mSlicingTransform; }
+  vtkTransform * GetConcatenatedTransform() { return mConcatenatedTransform; }
+  vtkTransform * GetConcatenatedFusionTransform() { return mConcatenatedFusionTransform; }
+  vtkTransform * GetConcatenatedOverlayTransform() { return mConcatenatedOverlayTransform; }
+
   void SetCurrentPosition(double x, double y, double z, int t);
-  double* GetCurrentPosition() {
-    return mCurrent;
-  }
+  double* GetCurrentPosition();
 
   void UpdateCursorPosition();
   void SetCursorVisibility(bool s);
@@ -206,11 +210,25 @@ protected:
 
   vvLandmarks* mLandmarks;
 
+  //                         __________ Image coordinates accounting for spacing and origin
+  //                            Λ  Λ
+  //                            |  | vvImage.GetTransform()
+  //                            |  |
+  // GetConcatenatedTransform() | _|___ VV world coordinates (mm) (displayed in VV)             mCurrentBeforeSlicingTransform
+  //                            |  Λ
+  //                            |  | GetSlicingTransform()
+  //                            |  |
+  //                         ___|__|___ VTK world coordinates (mm) (never displayed)            mCurrent
+
+  vtkSmartPointer<vtkTransform> mSlicingTransform;
   vtkSmartPointer<vtkImageReslice> mImageReslice;
+  vtkSmartPointer<vtkTransform> mConcatenatedTransform;
   vtkSmartPointer<vtkImageReslice> mOverlayReslice;
+  vtkSmartPointer<vtkTransform> mConcatenatedOverlayTransform;
   vtkSmartPointer<vtkImageMapToWindowLevelColors> mOverlayMapper;
   vtkSmartPointer<vvBlendImageActor> mOverlayActor;
   vtkSmartPointer<vtkImageReslice> mFusionReslice;
+  vtkSmartPointer<vtkTransform> mConcatenatedFusionTransform;
   vtkSmartPointer<vtkImageMapToColors> mFusionMapper;
   vtkSmartPointer<vtkImageActor> mFusionActor;
   vtkSmartPointer<vtkCornerAnnotation> ca;
@@ -234,7 +252,10 @@ protected:
   std::vector<vvMeshActor*> mSurfaceCutActors;
 
   int mCurrentTSlice;
+  int mCurrentFusionTSlice;
+  int mCurrentOverlayTSlice;
   double mCurrent[3];
+  double mCurrentBeforeSlicingTransform[3];
   double mCursor[4];
   int mSubSampling;
   int mScale;

diff --git a/vv/vvSlicerManager.cxx b/vv/vvSlicerManager.cxx
index dc75f8f91770351ff6de51b7d966b949407572ef..eb8977dd0548b890388f5cda415785e644d69ac1 100644 (file)
--- a/vv/vvSlicerManager.cxx
+++ b/vv/vvSlicerManager.cxx
@@ -72,6 +72,7 @@ vvSlicerManager::vvSlicerManager(int numberOfSlicers)
 
   mPreviousSlice.resize(numberOfSlicers);
   mPreviousTSlice.resize(numberOfSlicers);
+  mSlicingPreset = WORLD_SLICING;
 }
 //----------------------------------------------------------------------------
 
@@ -241,20 +242,18 @@ bool vvSlicerManager::SetImages(std::vector<std::string> filenames, vvImageReade
 
 
 //----------------------------------------------------------------------------
-bool vvSlicerManager::SetOverlay(std::string filename,int dim, std::string component)
+bool vvSlicerManager::SetOverlay(std::vector<std::string> filenames,int dim, std::string component, vvImageReader::LoadedImageType type)
 {
-  mOverlayName = filename;
+  mOverlayName = filenames[0];
   mOverlayComponent = component;
   if (dim > mImage->GetNumberOfDimensions()) {
-    mLastError = " Overlay dimension cannot be greater then reference image!";
+    mLastError = " Overlay dimension cannot be greater than reference image!";
     return false;
   }
   if (mOverlayReader.IsNull())
     mOverlayReader = vvImageReader::New();
-  std::vector<std::string> filenames;
-  filenames.push_back(filename);
   mOverlayReader->SetInputFilenames(filenames);
-  mOverlayReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);
+  mOverlayReader->Update(type);
   if (mOverlayReader->GetLastError().size() == 0) {
     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
       mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
@@ -426,6 +425,13 @@ void vvSlicerManager::SetSliceOrientation(int slicer, int orientation)
 }
 //----------------------------------------------------------------------------
 
+//----------------------------------------------------------------------------
+int vvSlicerManager::GetTSlice()
+{
+  return mSlicers[0]->GetTSlice();
+}
+//----------------------------------------------------------------------------
+
 //----------------------------------------------------------------------------
 void vvSlicerManager::SetTSlice(int slice)
 {
@@ -436,9 +442,9 @@ void vvSlicerManager::SetTSlice(int slice)
   if (mLandmarks)
     mLandmarks->SetTime(slice);
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
-    if (slice != mSlicers[i]->GetTSlice()) {
+    if (slice != mSlicers[i]->GetMaxCurrentTSlice()) {
       mSlicers[i]->SetTSlice(slice);
-        UpdateTSlice(i);
+      UpdateTSlice(i);
     }
   }
 }
@@ -448,7 +454,7 @@ void vvSlicerManager::SetTSlice(int slice)
 //----------------------------------------------------------------------------
 void vvSlicerManager::SetNextTSlice(int originating_slicer)
 {
-  int t = mSlicers[0]->GetTSlice();
+  int t = mSlicers[0]->GetMaxCurrentTSlice();
   t++;
   if (t > mSlicers[0]->GetTMax())
     t = 0;
@@ -461,7 +467,7 @@ void vvSlicerManager::SetNextTSlice(int originating_slicer)
 //----------------------------------------------------------------------------
 void vvSlicerManager::SetPreviousTSlice(int originating_slicer)
 {
-  int t = mSlicers[0]->GetTSlice();
+  int t = mSlicers[0]->GetMaxCurrentTSlice();
   t--;
   if (t < 0)
     t = mSlicers[0]->GetTMax();
@@ -496,9 +502,17 @@ void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)
   if (mLandmarks)
     mLandmarks->SetTime(tslice);
 
-  if (mSlicers[slicer]->GetTSlice() == tslice) return;
+  if (mSlicers[slicer]->GetMaxCurrentTSlice() == tslice) return;
 
   mSlicers[slicer]->SetTSlice(tslice);
+
+  if(mSlicingPreset==VOXELS_SLICING) {
+    vtkMatrix4x4 *imageTransformInverse = vtkMatrix4x4::New();
+    mImage->GetTransform()[mSlicers[slicer]->GetTSlice()]->GetInverse(imageTransformInverse);
+    this->GetSlicer(slicer)->GetSlicingTransform()->SetMatrix(imageTransformInverse);
+    imageTransformInverse->Delete();
+  }
+
   UpdateTSlice(slicer);
 }
 //----------------------------------------------------------------------------
@@ -570,36 +584,42 @@ void vvSlicerManager::SetOpacity(int i, double factor)
 //----------------------------------------------------------------------------
 void vvSlicerManager::UpdateViews(int current,int slicer)
 {
-  double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
+  double p[3], pt[3];
+  p[0] = mSlicers[slicer]->GetCurrentPosition()[0];
+  p[1] = mSlicers[slicer]->GetCurrentPosition()[1];
+  p[2] = mSlicers[slicer]->GetCurrentPosition()[2];
+  mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(p, pt);
+
+  double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
     /mSlicers[slicer]->GetInput()->GetSpacing()[0];
-  double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
+  double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
     /mSlicers[slicer]->GetInput()->GetSpacing()[1];
-  double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
+  double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
     /mSlicers[slicer]->GetInput()->GetSpacing()[2];
 
-  if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
-      x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
-      y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
-      y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
-      z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
-      z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {
+  if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&
+      x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&
+      y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&
+      y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&
+      z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&
+      z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) {
     mSlicers[slicer]->UpdateCursorPosition();
     mSlicers[slicer]->SetCursorColor(10,212,255);
 
     switch (mSlicers[slicer]->GetSliceOrientation()) {
     case vtkImageViewer2::SLICE_ORIENTATION_XY:
-      if (mSlicers[slicer]->GetSlice() != (int)floor(z))
-        mSlicers[slicer]->SetSlice((int)floor(z));
+      if (mSlicers[slicer]->GetSlice() != (int)lrint(z))
+        mSlicers[slicer]->SetSlice((int)lrint(z));
       break;
 
     case vtkImageViewer2::SLICE_ORIENTATION_XZ:
-      if (mSlicers[slicer]->GetSlice() != (int)floor(y))
-        mSlicers[slicer]->SetSlice((int)floor(y));
+      if (mSlicers[slicer]->GetSlice() != (int)lrint(y))
+        mSlicers[slicer]->SetSlice((int)lrint(y));
       break;
 
     case vtkImageViewer2::SLICE_ORIENTATION_YZ:
-      if (mSlicers[slicer]->GetSlice() != (int)floor(x))
-        mSlicers[slicer]->SetSlice((int)floor(x));
+      if (mSlicers[slicer]->GetSlice() != (int)lrint(x))
+        mSlicers[slicer]->SetSlice((int)lrint(x));
       break;
     }
     mSlicers[slicer]->Render();
@@ -609,14 +629,11 @@ void vvSlicerManager::UpdateViews(int current,int slicer)
           && mSlicers[i]->GetRenderer()->GetDraw()
           && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2
           && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2) {
-        mSlicers[i]->SetCurrentPosition(mSlicers[slicer]->GetCurrentPosition()[0],
-                                        mSlicers[slicer]->GetCurrentPosition()[1],
-                                        mSlicers[slicer]->GetCurrentPosition()[2],
-                                        mSlicers[slicer]->GetTSlice());
+        mSlicers[i]->SetCurrentPosition(p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());
         mSlicers[i]->UpdateCursorPosition();
         if (current) { //do not display corner annotation if image is the one picked
           mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,
-                                          -VTK_DOUBLE_MAX, mSlicers[slicer]->GetTSlice());
+                                          -VTK_DOUBLE_MAX, mSlicers[slicer]->GetMaxCurrentTSlice());
           mSlicers[i]->SetCursorColor(255,10,212);
         } else {
           mSlicers[i]->SetCursorColor(150,10,282);
@@ -652,23 +669,23 @@ void vvSlicerManager::UpdateViews(int current,int slicer)
 //----------------------------------------------------------------------------
 void vvSlicerManager::UpdateLinked(int slicer)
 {
-  double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
-    /mSlicers[slicer]->GetInput()->GetSpacing()[0];
-  double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
-    /mSlicers[slicer]->GetInput()->GetSpacing()[1];
-  double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
-    /mSlicers[slicer]->GetInput()->GetSpacing()[2];
-
-  if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
-      x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
-      y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
-      y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
-      z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
-      z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {
+  double p[3], pt[3];
+  p[0] = mSlicers[slicer]->GetCurrentPosition()[0];
+  p[1] = mSlicers[slicer]->GetCurrentPosition()[1];
+  p[2] = mSlicers[slicer]->GetCurrentPosition()[2];
+  mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(p, pt);
+  double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0]) / mSlicers[slicer]->GetInput()->GetSpacing()[0];
+  double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1]) / mSlicers[slicer]->GetInput()->GetSpacing()[1];
+  double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2]) / mSlicers[slicer]->GetInput()->GetSpacing()[2];
+
+  if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 &&
+      x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 &&
+      y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&
+      y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&
+      z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&
+      z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) {
     for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) {
-      emit UpdateLinkManager(*i, slicer,mSlicers[slicer]->GetCurrentPosition()[0],
-                             mSlicers[slicer]->GetCurrentPosition()[1],
-                             mSlicers[slicer]->GetCurrentPosition()[2],mSlicers[slicer]->GetTSlice());
+      emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());
     }
   }
 }
@@ -678,10 +695,16 @@ void vvSlicerManager::UpdateLinked(int slicer)
 void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate)
 {
   vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera();
-  double refPosition[3], refFocal[3];
+
+  double refPosition[3];
   refCam->GetPosition(refPosition);
-  refCam->GetFocalPoint(refFocal);
-  
+  refPosition[refSlicer->GetSliceOrientation()] = refSlicer->GetSlice() *
+      refSlicer->GetInput()->GetSpacing()[refSlicer->GetSliceOrientation()] +
+      refSlicer->GetInput()->GetOrigin()[refSlicer->GetSliceOrientation()];
+
+  refSlicer->GetSlicingTransform()->TransformPoint(refPosition, refPosition);
+  mSlicers[0]->GetSlicingTransform()->GetInverse()->TransformPoint(refPosition, refPosition);
+
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
     vtkCamera *camera = mSlicers[i]->GetRenderer()->GetActiveCamera();
     camera->SetParallelScale(refCam->GetParallelScale());
@@ -690,49 +713,16 @@ void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagat
     camera->GetPosition(position);
     camera->GetFocalPoint(focal);
 
-    if(refSlicer->GetSliceOrientation()==mSlicers[i]->GetSliceOrientation()) {
-      for(int i=0; i<3; i++) {
-        position[i] = refPosition[i];
-        focal[i]    = refFocal[i];
-      }
-    }
-
-    if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
-      if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
-        position[0] = refPosition[0];
-        focal[0]    = refFocal[0];
-      }
-      if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
-        position[1] = refPosition[1];
-        focal[1]    = refFocal[1];
-      }
-    }
-
-    if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
-      if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
-        position[2] = refPosition[2];
-        focal[2]    = refFocal[2];
-      }
-      if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
-        position[0] = refPosition[0];
-        focal[0]    = refFocal[0];
-      }
-    }
-
-    if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
-      if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
-        position[1] = refPosition[1];
-        focal[1]    = refFocal[1];
-      }
-      if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
-        position[2] = refPosition[2];
-        focal[2]    = refFocal[2];
+    for(int j=0; j<3; j++) {
+      if(j!=mSlicers[i]->GetSliceOrientation()) {
+        position[j] = refPosition[j];
+        focal[j]    = refPosition[j];
       }
     }
 
     camera->SetFocalPoint(focal);
     camera->SetPosition(position);
-  
+
     //Fix for bug #243
     mSlicers[i]->ForceUpdateDisplayExtent();
   }
@@ -794,13 +784,17 @@ bool vvSlicerManager::GetLinkOverlayWindowLevel() const
 void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType)
 {
   if(actorType == "image")
-    this->GetImage()->GetTransform()->Identity();
+    for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
+      this->GetImage()->GetTransform()[i]->Identity();
   else if(actorType == "overlay")
-    this->GetSlicer(0)->GetOverlay()->GetTransform()->Identity();
+    for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
+      this->GetSlicer(0)->GetOverlay()->GetTransform()[i]->Identity();
   else if(actorType == "fusion")
-    this->GetSlicer(0)->GetFusion()->GetTransform()->Identity();
+    for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
+      this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity();
   else if(actorType == "vf")
-    this->GetVF()->GetTransform()->Identity();
+    for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)
+      this->GetVF()->GetTransform()[i]->Identity();
   else
     return;
 
@@ -946,7 +940,7 @@ void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
 
     if (mSlicers[slicer]->GetVFActor() ) {
       displayVec = 1;
-      unsigned int currentTime = mSlicers[slicer]->GetTSlice();
+      unsigned int currentTime = mSlicers[slicer]->GetMaxCurrentTSlice();
       vtkImageData *vf = NULL;
 
       if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)
@@ -1033,7 +1027,7 @@ void vvSlicerManager::UpdateSlice(int slicer)
 void vvSlicerManager::UpdateTSlice(int slicer)
 {
   int slice = mSlicers[slicer]->GetSlice();
-  int tslice = mSlicers[slicer]->GetTSlice();
+  int tslice = mSlicers[slicer]->GetMaxCurrentTSlice();
   if (mPreviousSlice[slicer] == slice) {
     if (mPreviousTSlice[slicer] == tslice) {
       //      DD("************** NOTHING ***********");
@@ -1057,6 +1051,41 @@ void vvSlicerManager::UpdateSliceRange(int slicer)
 }
 //----------------------------------------------------------------------------
 
+//----------------------------------------------------------------------------
+void vvSlicerManager::SetSlicingPreset(SlicingPresetType preset)
+{
+  if(mSlicingPreset==preset)
+    return;
+
+  vtkMatrix4x4 *imageTransformInverse = vtkMatrix4x4::New();
+  mImage->GetTransform()[this->GetTSlice()]->GetInverse(imageTransformInverse);
+
+  for(int i=0; i< this->GetNumberOfSlicers(); i++){
+    vvSlicer *s = this->GetSlicer(i);
+    switch(preset)
+    {
+    case WORLD_SLICING:
+      s->GetSlicingTransform()->Identity();
+      break;
+    case VOXELS_SLICING:
+      s->GetSlicingTransform()->SetMatrix(imageTransformInverse);
+      break;
+    default:
+      imageTransformInverse->Delete();
+      return;
+    }
+    s->ForceUpdateDisplayExtent();
+    s->SetSlice((s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2+1]
+                +s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2])/2.0);
+    s->ResetCamera();
+    s->Render();
+  }
+
+  imageTransformInverse->Delete();
+  mSlicingPreset = preset;
+}
+
+//----------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
 void vvSlicerManager::SetPreset(int preset)
@@ -1116,19 +1145,20 @@ void vvSlicerManager::SetPreset(int preset)
 void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlKey)
 {
   double min, max;
-  int t = this->mSlicers[slicer]->GetTSlice();
   if(bCtrlKey && this->mSlicers[slicer]->GetFusion()) {
+    int t = mSlicers[slicer]->GetFusionTSlice();
     this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
                                                           this->mSlicers[slicer]->GetFusion()->GetVTKImages()[t],
-                                                          this->mSlicers[slicer]->GetFusion()->GetTransform());
+                                                          this->mSlicers[slicer]->GetConcatenatedFusionTransform());
     this->SetFusionWindow(max-min);
     this->SetFusionLevel(0.5*(min+max));
     this->SetColorMap(mColorMap);
   }
   else if(bCtrlKey && this->mSlicers[slicer]->GetOverlay()) {
+    int t = mSlicers[slicer]->GetOverlayTSlice();
     this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
                                                           this->mSlicers[slicer]->GetOverlay()->GetVTKImages()[t],
-                                                          this->mSlicers[slicer]->GetOverlay()->GetTransform());
+                                                          this->mSlicers[slicer]->GetConcatenatedOverlayTransform());
     if(this->mSlicers[slicer]->GetLinkOverlayWindowLevel()){
       this->SetColorWindow(max-min);
       this->SetColorLevel(0.5*(min+max));
@@ -1138,9 +1168,10 @@ void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlK
     }
   }
   else {
+    int t = this->GetTSlice();
     this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max,
                                                           this->mSlicers[slicer]->GetImage()->GetVTKImages()[t],
-                                                          this->mSlicers[slicer]->GetImage()->GetTransform());
+                                                          this->mSlicers[slicer]->GetConcatenatedTransform());
     this->SetColorWindow(max-min);
     this->SetColorLevel(0.5*(min+max));
     this->SetPreset(6);
@@ -1319,12 +1350,12 @@ void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
   double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];
   double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];
   double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];
-  if (x_index >= mSlicers[0]->GetInput()->GetWholeExtent()[0] &&
-      x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1] &&
-      y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2] &&
-      y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3] &&
-      z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4] &&
-      z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]) {
+  if (x_index >= mSlicers[0]->GetInput()->GetWholeExtent()[0]-0.5 &&
+      x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1]+0.5 &&
+      y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2]-0.5 &&
+      y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3]+0.5 &&
+      z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4]-0.5 &&
+      z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]+0.5) {
     double value = this->GetScalarComponentAsDouble(mSlicers[0]->GetInput(), x_index, y_index, z_index);
     this->GetLandmarks()->AddLandmark(x,y,z,t,value);
     emit LandmarkAdded();

diff --git a/vv/vvSlicerManager.h b/vv/vvSlicerManager.h
index 9858d69fdb23f0615c8666e8ee24e1d68e200148..088df6171a39d2fa7467b63ff42843d86e448271 100644 (file)
--- a/vv/vvSlicerManager.h
+++ b/vv/vvSlicerManager.h
@@ -52,6 +52,7 @@ class vvSlicerManager : public QObject {
   Q_OBJECT
 
   public:
+  typedef enum {WORLD_SLICING, VOXELS_SLICING} SlicingPresetType;
   vvSlicerManager(int numberOfSlicers);
   ~vvSlicerManager();
 
@@ -63,7 +64,7 @@ class vvSlicerManager : public QObject {
   void SetImage(vvImage::Pointer image);
   bool SetImages(std::vector<std::string> filenames, vvImageReader::LoadedImageType type, int n=0);
 
-  bool SetOverlay(std::string filename, int dim, std::string component);
+  bool SetOverlay(std::vector<std::string> filenames, int dim, std::string component, vvImageReader::LoadedImageType type);
   bool SetFusion(std::string filename, int dim, std::string component);
   ///Set a VF by loading it from the disk
   bool SetVF(std::string filename);
@@ -103,6 +104,7 @@ class vvSlicerManager : public QObject {
   void SetFilename(std::string f, int number=0);
 
   void SetSliceOrientation(int slicer, int orientation);
+  int GetTSlice();
   void SetTSlice(int slice);
   void SetNextTSlice(int originating_slicer);
   void SetPreviousTSlice(int originating_slicer);
@@ -151,6 +153,9 @@ class vvSlicerManager : public QObject {
   int GetPreset() {
     return mPreset;
   }
+  SlicingPresetType GetSlicingPreset() {
+    return mSlicingPreset;
+  }
   int GetOverlayColor() const {
     return mOverlayColor;
   }
@@ -203,6 +208,7 @@ class vvSlicerManager : public QObject {
   void UpdateSlice(int slicer);
   void UpdateTSlice(int slicer);
   void UpdateSliceRange(int slicer);
+  void SetSlicingPreset(SlicingPresetType preset);
 
   vvLandmarks *GetLandmarks();
   void AddLandmark(float x,float y,float z,float t);
@@ -251,6 +257,7 @@ protected:
   bool mFusionShowLegend;
 
   int mPreset;
+  SlicingPresetType mSlicingPreset;
   vvImageReader::LoadedImageType mType;
   std::string mVFComponent;
   std::string mOverlayComponent;

diff --git a/vv/vvSlicerManagerCommand.cxx b/vv/vvSlicerManagerCommand.cxx
index 1b7103301b7d9f0544c731c14ccca913a623657d..73a0ab5efda3e79ba42b604908662a2149806b4b 100644 (file)
--- a/vv/vvSlicerManagerCommand.cxx
+++ b/vv/vvSlicerManagerCommand.cxx
@@ -271,7 +271,7 @@ void vvSlicerManagerCommand::Execute(vtkObject *caller,
       //All type of mouse events
       if (event == vtkCommand::LeaveEvent) {
         this->SM->GetSlicer(VisibleInWindow)->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,
-            -VTK_DOUBLE_MAX,this->SM->GetSlicer(VisibleInWindow)->GetTSlice());
+            -VTK_DOUBLE_MAX,this->SM->GetSlicer(VisibleInWindow)->GetMaxCurrentTSlice());
         this->SM->GetSlicer(VisibleInWindow)->Render();
         return;
       }
@@ -362,8 +362,13 @@ void vvSlicerManagerCommand::Execute(vtkObject *caller,
         zWorld = z;
         break;
       }
-      this->SM->GetSlicer(VisibleInWindow)->SetCurrentPosition(xWorld,yWorld,zWorld,
-          this->SM->GetSlicer(VisibleInWindow)->GetTSlice());
+
+      double p[3]; p[0] = xWorld; p[1] = yWorld; p[2] = zWorld;
+      double pt[3];
+      this->SM->GetSlicer(VisibleInWindow)->GetSlicingTransform()->TransformPoint(p, pt);
+
+      this->SM->GetSlicer(VisibleInWindow)->SetCurrentPosition(pt[0],pt[1],pt[2],
+          this->SM->GetSlicer(VisibleInWindow)->GetMaxCurrentTSlice());
       if (newLandmark) {
         this->SM->AddLandmark(xWorld,yWorld,zWorld,
                               this->SM->GetSlicer(VisibleInWindow)->GetTSlice());

diff --git a/vv/vvToolRigidReg.cxx b/vv/vvToolRigidReg.cxx
index 28591ba05ed1b6c6cc8af79af440ef5eaea6eb37..508551da86a7dec2ed064921e170439f2d6faeff 100644 (file)
--- a/vv/vvToolRigidReg.cxx
+++ b/vv/vvToolRigidReg.cxx
@@ -118,7 +118,8 @@ void vvToolRigidReg::InputIsSelected(vvSlicerManager *input)
   //backup original matrix
   for(int j=0; j<4; j++)
     for(int i=0; i<4; i++)
-      mInitialMatrix->SetElement(i,j, mCurrentSlicerManager->GetImage()->GetTransform()->GetMatrix()->GetElement(i,j));
+      // TODO SR and BP: check on the list of transforms and not the first only
+      mInitialMatrix->SetElement(i,j, mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix()->GetElement(i,j));
   QString origTransformString = dynamic_cast<vvMainWindow*>(mMainWindow)->Get4x4MatrixDoubleAsString(mInitialMatrix);
   transformationLabel->setText(origTransformString);
   SetTransform(mInitialMatrix);
@@ -242,7 +243,8 @@ void vvToolRigidReg::SpinBoxChange(double newVal)
   }
 
   // Compute transform and set
-  vtkSmartPointer<vtkTransform> transform_final=mInput->GetImage()->GetTransform();
+  // TODO SR and BP: check on the list of transforms and not the first only
+  vtkSmartPointer<vtkTransform> transform_final=mInput->GetImage()->GetTransform()[0];
   transform_final->Identity();
   transform_final->PostMultiply();
 
@@ -294,7 +296,8 @@ void vvToolRigidReg::SaveFile()
 
   QFile file(filename);
   if (file.open(QFile::WriteOnly | QFile::Truncate)) {
-    vtkMatrix4x4* matrix = mCurrentSlicerManager->GetImage()->GetTransform()->GetMatrix();
+    // TODO SR and BP: check on the list of transforms and not the first only
+    vtkMatrix4x4* matrix = mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix();
     QString matrixStr = dynamic_cast<vvMainWindow*>(mMainWindow)->Get4x4MatrixDoubleAsString(matrix,16);
     QTextStream out(&file);
     out << matrixStr;
@@ -332,7 +335,8 @@ void vvToolRigidReg::LoadFile()
 //------------------------------------------------------------------------------
 void vvToolRigidReg::ChangeOfRotationCenter()
 {
-  SetTransform(mCurrentSlicerManager->GetImage()->GetTransform()->GetMatrix());
+  // TODO SR and BP: check on the list of transforms and not the first only
+  SetTransform(mCurrentSlicerManager->GetImage()->GetTransform()[0]->GetMatrix());
 }
 //------------------------------------------------------------------------------
 
@@ -347,7 +351,8 @@ void vvToolRigidReg::ResetTransform()
 void vvToolRigidReg::SetTransform(vtkMatrix4x4 *matrix)
 {
   vtkSmartPointer<vtkTransform> transform=vtkSmartPointer<vtkTransform>::New();
-  mCurrentSlicerManager->GetImage()->GetTransform()->SetMatrix(matrix);
+  // TODO SR and BP: check on the list of transforms and not the first only
+  mCurrentSlicerManager->GetImage()->GetTransform()[0]->SetMatrix(matrix);
   transform->Update();
   Render();
   dynamic_cast<vvMainWindow*>(mMainWindow)->ImageInfoChanged();