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

diff --git a/tools/clitkWriteDicomSeriesGenericFilter.txx b/tools/clitkWriteDicomSeriesGenericFilter.txx
index 83041c377631470953dd1afb568e3dc35492bf7a..480e4969847db27b312e63f59f5b6214ed184fbb 100644 (file)
--- a/tools/clitkWriteDicomSeriesGenericFilter.txx
+++ b/tools/clitkWriteDicomSeriesGenericFilter.txx
@@ -308,11 +308,11 @@ WriteDicomSeriesGenericFilter<args_info_type>::UpdateWithDimAndPixelType()
   bool useInputFileUID = true;
   if (m_ArgsInfo.newSeriesUID_flag || m_ArgsInfo.newStudyUID_flag || seriesUIDGiven || studyUIDGiven) {
     useInputFileUID = false;
+  }
+  else {
 #if GDCM_MAJOR_VERSION < 2
     gdcmIO->SetKeepOriginalUID(true);
 #endif
-  }
-  else {
     namesGenerator->SetOutputDirectory( m_ArgsInfo.outputDir_arg  );
     filenames_out = namesGenerator->GetOutputFileNames();
   }

diff --git a/vv/vv.cxx b/vv/vv.cxx
index b4beaa8dcdf7f5a18799793a3025141792fc1514..47057e4a0ed335cc3720cec279c5ffcfab6f9c29 100644 (file)
--- a/vv/vv.cxx
+++ b/vv/vv.cxx
@@ -140,6 +140,8 @@ int main( int argc, char** argv )
   int n_image_loaded=0;
   std::string win(""), lev("");
 
+  int first_of_wl_set = -1;
+  bool new_wl_set = false;
        bool link_images = false;
   if (argc >1) {
     for (int i = 1; i < argc; i++) {
@@ -150,11 +152,15 @@ int main( int argc, char** argv )
         } 
         else if (parse_mode == P_WINDOW) { // handle negative window values
           win=current;
+          window.ApplyWindowToSetOfImages(atof(win.c_str()), first_of_wl_set, n_image_loaded-1);
           parse_mode=P_NORMAL;
+          new_wl_set = false;
           continue;
         } else if (parse_mode == P_LEVEL) { // handle negative level values
           lev=current;
+          window.ApplyLevelToSetOfImages(atof(lev.c_str()), first_of_wl_set, n_image_loaded-1);
           parse_mode=P_NORMAL;
+          new_wl_set = false;
           continue;
         }
         if ((current=="--help") || (current=="-h")) {
@@ -163,8 +169,8 @@ int main( int argc, char** argv )
                     << "Open file(s) for visualization." << std::endl << std::endl
                     << "OPTIONS may be:" << std::endl
                     << "--help         \t Print command line help and exit." << std::endl
-                    << "--window number\t Gray scale window width for all images." << std::endl
-                    << "--level number \t Gray scale window level for all images." << std::endl
+                    << "--window number\t Gray scale window width for set of images appearing before in the cmd line (may appear more than once)." << std::endl
+                    << "--level number \t Gray scale window level for set of images appearing before in the cmd line (may appear more than once)." << std::endl
                     << "--linkall      \t Link pan, zoom and spatial position of crosshair in images." << std::endl
                     << "--log          \t Log output messages in vv-log directory." << std::endl
                     << "--state file   \t Read display parameters from file." << std::endl
@@ -192,14 +198,18 @@ int main( int argc, char** argv )
         } else if (current == "--sequence") {
           if(open_mode==O_BASE) n_image_loaded++; //count only one for the whole sequence
           parse_mode=P_SEQUENCE;
+          if (!new_wl_set) {
+            new_wl_set = true;
+            first_of_wl_set = n_image_loaded-1;
+          }
         } else if (current == "--window") {
           parse_mode=P_WINDOW;
         } else if (current == "--level") {
           parse_mode=P_LEVEL;
         } else if (current == "--linkall") {
-         link_images = true;
-       }
-       else if (current == "--log") {
+          link_images = true;
+        }
+        else if (current == "--log") {
           std::string log_dir = QDir::tempPath().toStdString() + std::string("/vv-log");
 
           if(itksys::SystemTools::FileExists(log_dir.c_str()) &&
@@ -236,16 +246,24 @@ int main( int argc, char** argv )
         sequence_filenames.push_back(current);
       } else if (parse_mode == P_WINDOW) {
         win=current;
+        window.ApplyWindowToSetOfImages(atof(win.c_str()), first_of_wl_set, n_image_loaded-1);
         parse_mode=P_NORMAL;
+        new_wl_set = false;
       } else if (parse_mode == P_LEVEL) {
         lev=current;
+        window.ApplyLevelToSetOfImages(atof(lev.c_str()), first_of_wl_set, n_image_loaded-1);
         parse_mode=P_NORMAL;
+        new_wl_set = false;
       } else {
         std::vector<std::string> image;
         image.push_back(current);
         if(open_mode==O_BASE) {
           window.LoadImages(image, vvImageReader::IMAGE);
           n_image_loaded++;
+          if (!new_wl_set) {
+            new_wl_set = true;
+            first_of_wl_set = n_image_loaded-1;
+          }
         }
         else if (open_mode==O_VF)
           window.AddField(current.c_str(), n_image_loaded-1);
@@ -263,10 +281,10 @@ int main( int argc, char** argv )
     }
   }
 
-  if(win!="" && lev!="") {
-    window.SetWindowLevel(atof(win.c_str()), atof(lev.c_str()));
-    window.ApplyWindowLevelToAllImages();
-  }
+//   if(win!="" && lev!="") {
+//     window.SetWindowLevel(atof(win.c_str()), atof(lev.c_str()));
+//     window.ApplyWindowLevelToAllImages();
+//   }
 
   if (link_images)
     window.LinkAllImages();

diff --git a/vv/vvInteractorStyleNavigator.cxx b/vv/vvInteractorStyleNavigator.cxx
index 712e069672eb324d1f883a2a3e03bcebee8d0214..ac37a8fd22c95442157365a2a03ad3409d662ed1 100644 (file)
--- a/vv/vvInteractorStyleNavigator.cxx
+++ b/vv/vvInteractorStyleNavigator.cxx
@@ -249,7 +249,10 @@ void vvInteractorStyleNavigator::OnLeftButtonDown()
 
   // Redefine this button to handle pick
   this->GrabFocus(this->EventCallbackCommand);
-  if (!this->Interactor->GetShiftKey() && !this->Interactor->GetControlKey()) {
+  if (this->Interactor->GetShiftKey()) {
+    this->OnMiddleButtonDown();
+  }
+  else if (!this->Interactor->GetControlKey()) {
     this->StartPick();
   }
 
@@ -271,6 +274,9 @@ void vvInteractorStyleNavigator::OnLeftButtonUp()
       this->ReleaseFocus();
     }
     break;
+  case VTKIS_PAN:
+    this->OnMiddleButtonUp();
+    break;
   }
 
   // Call parent to handle all other states and perform additional work

diff --git a/vv/vvLinkPanel.cxx b/vv/vvLinkPanel.cxx
index 87f3a0fcae8fc364a7d61b04aec414fe30256a5e..5b890d1057de1c5d55bde8edfdd0a1ead29bd9af 100644 (file)
--- a/vv/vvLinkPanel.cxx
+++ b/vv/vvLinkPanel.cxx
@@ -152,6 +152,29 @@ void vvLinkPanel::linkAll()
 }
 //------------------------------------------------------------------------------
 
+//------------------------------------------------------------------------------
+void vvLinkPanel::addLinkFromIds(QString id1, QString id2)
+{
+  int index1 = -1, index2 = -1;
+  size_t s1 = image1Ids.size();
+  size_t s2 = image2Ids.size();
+  for (size_t i = 0; i < s1 && index1 == -1; i++)
+    if (image1Ids[i] == id1.toStdString())
+      index1 = i;
+
+  if (index1 >= 0)
+    image1ComboBox->setCurrentIndex(index1);
+    
+  for (size_t i = 0; i < s2 && index2 == -1; i++)
+    if (image2Ids[i] == id2.toStdString())
+      index2 = i;
+  
+  if (index1 >= 0 && index2 >= 0) {
+    image2ComboBox->setCurrentIndex(index2);
+    addLink();
+  }
+}
+//------------------------------------------------------------------------------
 
 //------------------------------------------------------------------------------
 void vvLinkPanel::addLink()
@@ -182,7 +205,9 @@ void vvLinkPanel::addLink()
     linkTableWidget->setRowHeight(row,17);
 
     emit addLink(image1Ids[image1ComboBox->currentIndex()].c_str(),
-                 image2Ids[image2ComboBox->currentIndex()].c_str());
+                 image2Ids[image2ComboBox->currentIndex()].c_str(),
+                 true
+                );
     UpdateComboBox2(image1ComboBox->currentIndex());
   }
 

diff --git a/vv/vvLinkPanel.h b/vv/vvLinkPanel.h
index 2302407bdba3c6c062a96f9d9349e018494185ca..c73cde4966b59045c64d9a4fcfbd3327d3374ba4 100644 (file)
--- a/vv/vvLinkPanel.h
+++ b/vv/vvLinkPanel.h
@@ -34,6 +34,7 @@ public:
     ~vvLinkPanel() {}
 
     void addImage(std::string name, std::string id);
+    void addLinkFromIds(QString id1, QString id2);
     void removeImage(int i);
     bool isLinkAll();
 
@@ -44,7 +45,7 @@ public slots :
     void linkAll();
 
 signals:
-    void addLink(QString image1,QString image2);
+    void addLink(QString image1,QString image2,bool);
     void removeLink(QString image1,QString image2);
 
 private:

diff --git a/vv/vvMainWindow.cxx b/vv/vvMainWindow.cxx
index 8f94ff664c8bdb033e3228d57f54f4126d81b4ba..bca77cf7b0ab937b0999d01da71206569b925280 100644 (file)
--- a/vv/vvMainWindow.cxx
+++ b/vv/vvMainWindow.cxx
@@ -315,7 +315,7 @@ vvMainWindow::vvMainWindow():vvMainWindowBase()
 
   connect(this,SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(ShowContextMenu(QPoint)));
 
-  connect(linkPanel,SIGNAL(addLink(QString,QString)),this,SLOT(AddLink(QString,QString)));
+  connect(linkPanel,SIGNAL(addLink(QString,QString,bool)),this,SLOT(AddLink(QString,QString,bool)));
   connect(linkPanel,SIGNAL(removeLink(QString,QString)),this,SLOT(RemoveLink(QString,QString)));
   connect(overlayPanel,SIGNAL(VFPropertyUpdated(int,int,int,int,double,double,double)),this,SLOT(SetVFProperty(int,int,int,int,double,double,double)));
   connect(overlayPanel,SIGNAL(OverlayPropertyUpdated(int,int,double,double)),
@@ -928,7 +928,7 @@ void vvMainWindow::LoadImages(std::vector<std::string> files, vvImageReader::Loa
         DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
 
         //set the id of the image
-        QString id = files[i].c_str() + QString::number(mSlicerManagers.size()-1);
+        QString id = QDir::current().absoluteFilePath(files[i].c_str()) + QString::number(mSlicerManagers.size()-1);
         item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
         mSlicerManagers.back()->SetId(id.toStdString());
 
@@ -1237,25 +1237,70 @@ void vvMainWindow::ShowHelpDialog()
 //------------------------------------------------------------------------------
 void vvMainWindow::ChangeViewMode()
 {
-  QList<int> size;
+  typedef struct _SIZE{
+    QSplitter* splitter;
+    QList<int> size1, size2;
+    int cols[3];
+  }SplitterSize;
+  SplitterSize sizes[4];
+  sizes[0].splitter = OSplitter;
+  sizes[0].size1.push_back(1);
+  sizes[0].size1.push_back(0);
+  sizes[0].size2.push_back(1);
+  sizes[0].size2.push_back(0);
+  sizes[0].cols[0] = 2;
+  sizes[0].cols[1] = 3;
+  sizes[0].cols[2] = 4;
+
+  sizes[1].splitter = ESplitter;
+  sizes[1].size1.push_back(0);
+  sizes[1].size1.push_back(1);
+  sizes[1].size2.push_back(1);
+  sizes[1].size2.push_back(0);
+  sizes[1].cols[0] = 1;
+  sizes[1].cols[1] = 3;
+  sizes[1].cols[2] = 4;
+
+  sizes[2].splitter = OSplitter;
+  sizes[2].size1.push_back(1);
+  sizes[2].size1.push_back(0);
+  sizes[2].size2.push_back(0);
+  sizes[2].size2.push_back(1);
+  sizes[2].cols[0] = 1;
+  sizes[2].cols[1] = 2;
+  sizes[2].cols[2] = 4;
+
+  sizes[3].splitter = ESplitter;
+  sizes[3].size1.push_back(0);
+  sizes[3].size1.push_back(1);
+  sizes[3].size2.push_back(0);
+  sizes[3].size2.push_back(1);
+  sizes[3].cols[0] = 1;
+  sizes[3].cols[1] = 2;
+  sizes[3].cols[2] = 3;
+  
+  int slicer = mSlicerManagers[mCurrentPickedImageIndex]->GetSelectedSlicer();
   if (viewMode == 1) {
-    viewMode = 0;
-    size.push_back(1);
-    size.push_back(0);
-    splitter_3->setSizes(size);
-    OSplitter->setSizes(size);
-    DataTree->setColumnHidden(2,1);
-    DataTree->setColumnHidden(3,1);
-    DataTree->setColumnHidden(4,1);
+    if (slicer >= 0) {
+      viewMode = 0;
+      splitter_3->setSizes(sizes[slicer].size1);
+      sizes[slicer].splitter->setSizes(sizes[slicer].size2);
+      DataTree->setColumnHidden(sizes[slicer].cols[0],1);
+      DataTree->setColumnHidden(sizes[slicer].cols[1],1);
+      DataTree->setColumnHidden(sizes[slicer].cols[2],1);
+    }
   } else {
-    viewMode = 1;
-    size.push_back(1);
-    size.push_back(1);
-    splitter_3->setSizes(size);
-    OSplitter->setSizes(size);
-    DataTree->setColumnHidden(2,0);
-    DataTree->setColumnHidden(3,0);
-    DataTree->setColumnHidden(4,0);
+    QList<int> size;
+    if (slicer >= 0) {
+      viewMode = 1;
+      size.push_back(1);
+      size.push_back(1);
+      splitter_3->setSizes(size);
+      sizes[slicer].splitter->setSizes(size);
+      DataTree->setColumnHidden(sizes[slicer].cols[0],0);
+      DataTree->setColumnHidden(sizes[slicer].cols[1],0);
+      DataTree->setColumnHidden(sizes[slicer].cols[2],0);
+    }
   }
   UpdateRenderWindows();
   /*
@@ -1263,10 +1308,12 @@ void vvMainWindow::ChangeViewMode()
   ** the associated Slicer to redraw crosses.
   */
   for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
-    if (DataTree->topLevelItem(i)->data(COLUMN_UL_VIEW,Qt::CheckStateRole).toInt() > 1)
+//     if (DataTree->topLevelItem(i)->data(COLUMN_UL_VIEW,Qt::CheckStateRole).toInt() > 1)
       mSlicerManagers[i]->GetSlicer(0)->Render();
-    if (DataTree->topLevelItem(i)->data(COLUMN_DL_VIEW,Qt::CheckStateRole).toInt() > 1)
+      mSlicerManagers[i]->GetSlicer(1)->Render();
+//     if (DataTree->topLevelItem(i)->data(COLUMN_DL_VIEW,Qt::CheckStateRole).toInt() > 1)
       mSlicerManagers[i]->GetSlicer(2)->Render();
+      mSlicerManagers[i]->GetSlicer(3)->Render();
   }
 }
 //------------------------------------------------------------------------------
@@ -1769,6 +1816,32 @@ void vvMainWindow::ApplyWindowLevelToAllImages()
 }
 //------------------------------------------------------------------------------
 
+//------------------------------------------------------------------------------
+void vvMainWindow::ApplyWindowToSetOfImages(double window, unsigned int indexMin, unsigned int indexMax)
+{
+  for (unsigned int i = indexMin; i <= indexMax && i < mSlicerManagers.size(); i++) {
+    if (mSlicerManagers[i] == NULL)
+      continue;
+    mSlicerManagers[i]->SetColorWindow(window);
+    mSlicerManagers[i]->SetPreset(6);
+    mSlicerManagers[i]->Render();
+  }
+}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+void vvMainWindow::ApplyLevelToSetOfImages(double level, unsigned int indexMin, unsigned int indexMax)
+{
+  for (unsigned int i = indexMin; i <= indexMax && i < mSlicerManagers.size(); i++) {
+    if (mSlicerManagers[i] == NULL)
+      continue;
+    mSlicerManagers[i]->SetColorLevel(level);
+    mSlicerManagers[i]->SetPreset(6);
+    mSlicerManagers[i]->Render();
+  }
+}
+//------------------------------------------------------------------------------
+
 //------------------------------------------------------------------------------
 void vvMainWindow::UpdateLinkManager(std::string id, int slicer, double x, double y, double z, int temps)
 {
@@ -2413,8 +2486,14 @@ void vvMainWindow::LinkAllImages()
 }
 
 //------------------------------------------------------------------------------
-void vvMainWindow::AddLink(QString image1,QString image2)
+void vvMainWindow::AddLink(QString image1,QString image2,bool fromPanel)
 {
+  if (!fromPanel) {
+    // delegate to linkPanel if call came from elsewhere...
+    linkPanel->addLinkFromIds(image1, image2);
+    return;
+  }
+  
   unsigned int sm1 = 0;
   unsigned int sm2 = 0;
 
@@ -2671,23 +2750,24 @@ void vvMainWindow::UpdateTSlice(int slicer, int slice)
 //------------------------------------------------------------------------------
 void vvMainWindow::UpdateSliceRange(int slicer, int min, int max, int tmin, int tmax)
 {
-  int position = int((min+max)/2);
+  //int position = int((min+max)/2);
+  int position = mSlicerManagers[mCurrentPickedImageIndex]->GetSlicer(slicer)->GetSlice();
   if (slicer == 0) {
-    NOVerticalSlider->setValue(position);
     NOVerticalSlider->setRange(min,max);
     NOHorizontalSlider->setRange(tmin,tmax);
+    NOVerticalSlider->setValue(position);
   } else if (slicer == 1) {
-    NEVerticalSlider->setValue(position);
     NEVerticalSlider->setRange(min,max);
     NEHorizontalSlider->setRange(tmin,tmax);
+    NEVerticalSlider->setValue(position);
   } else if (slicer == 2) {
-    SOVerticalSlider->setValue(position);
     SOVerticalSlider->setRange(min,max);
     SOHorizontalSlider->setRange(tmin,tmax);
+    SOVerticalSlider->setValue(position);
   } else if (slicer == 3) {
-    SEVerticalSlider->setValue(position);
     SEVerticalSlider->setRange(min,max);
     SEHorizontalSlider->setRange(tmin,tmax);
+    SEVerticalSlider->setValue(position);
   }
 }
 //------------------------------------------------------------------------------
@@ -3074,7 +3154,7 @@ vvSlicerManager* vvMainWindow::AddImage(vvImage::Pointer image,std::string filen
   DataTree->setItemWidget(item, COLUMN_RELOAD_IMAGE, rButton);
 
   //set the id of the image
-  QString id = slicer_manager->GetFileName().c_str() + QString::number(mSlicerManagers.size()-1);
+  QString id = QDir::current().absoluteFilePath(slicer_manager->GetFileName().c_str()) + QString::number(mSlicerManagers.size()-1);
   item->setData(COLUMN_IMAGE_NAME,Qt::UserRole,id.toStdString().c_str());
   mSlicerManagers.back()->SetId(id.toStdString());
 

diff --git a/vv/vvMainWindow.h b/vv/vvMainWindow.h
index 015a468924ec6a1e9836d24aeae884352cd781b5..e308314c59620094e59ac7bb778856154089283c 100644 (file)
--- a/vv/vvMainWindow.h
+++ b/vv/vvMainWindow.h
@@ -121,9 +121,11 @@ public slots:
   void UpdateSlicingPreset();
   void SwitchWindowLevel();
   void ApplyWindowLevelToAllImages();
+  void ApplyWindowToSetOfImages(double window, unsigned int indexMin, unsigned int indexMax);
+  void ApplyLevelToSetOfImages(double level, unsigned int indexMin, unsigned int indexMax);
   void UpdateLinkManager(std::string id, int slicer, double x, double y, double z, int temps);
   void UpdateLinkedNavigation(std::string id, vvSlicerManager *sm, vvSlicer* refSlicer);
-  void AddLink(QString image1,QString image2);
+  void AddLink(QString image1,QString image2,bool fromPanel = true);
   void RemoveLink(QString image1,QString image2);
   void ChangeImageWithIndexOffset(vvSlicerManager *sm, int slicer, int offset);
 

diff --git a/vv/vvReadState.cxx b/vv/vvReadState.cxx
index 6d61ca5df6b8d0132fb75be64459bfe18bac46fe..980bbf1ffeac7a832fc086265f68f14a05911dd0 100644 (file)
--- a/vv/vvReadState.cxx
+++ b/vv/vvReadState.cxx
@@ -73,6 +73,7 @@ void vvReadState::ReadTree()
 {
   std::string value;
   
+  // read images
   while (!m_XmlReader->isEndElement() || value != "Images") { 
     m_XmlReader->readNext();
     value = m_XmlReader->qualifiedName().toString().toStdString();
@@ -81,6 +82,15 @@ void vvReadState::ReadTree()
     } 
   }
   
+  // read links
+  while (!m_XmlReader->isEndElement() || value != "Links") { 
+    m_XmlReader->readNext();
+    value = m_XmlReader->qualifiedName().toString().toStdString();
+    if (m_XmlReader->isStartElement()) {
+      if (value == "LinkedFrom") value = ReadLink();
+    } 
+  }
+
   if (m_XmlReader->hasError())
     std::cout << "Error " << m_XmlReader->error() << " XML " << std::endl;
 }
@@ -111,7 +121,23 @@ std::string  vvReadState::ReadImage()
         }
       }
       else if (current_index >= 0) {
-        if (value == "Fusion")
+        vvSlicerManager* slicerManager = m_Window->GetSlicerManagers()[current_index];
+        if (value == "Preset") {
+          double vali = m_XmlReader->readElementText().toInt();
+          if (!m_XmlReader->hasError())
+            slicerManager->SetPreset(vali);
+        }
+        else if (value == "Window") {
+          double vald = m_XmlReader->readElementText().toDouble();
+          if (!m_XmlReader->hasError())
+            slicerManager->SetColorWindow(vald);
+        }
+        else if (value == "Level") {
+          double vald = m_XmlReader->readElementText().toDouble();
+          if (!m_XmlReader->hasError())
+            slicerManager->SetColorLevel(vald);
+        }
+        else if (value == "Fusion")
           value = ReadFusion(current_index);
         else if (value == "Overlay")
           value = ReadOverlay(current_index);
@@ -246,6 +272,33 @@ std::string vvReadState::ReadVector(int index)
 //------------------------------------------------------------------------------
 
 
+//------------------------------------------------------------------------------
+std::string  vvReadState::ReadLink()
+{
+  std::string id_from, id_to, value;
+  
+  QXmlStreamAttributes attributes = m_XmlReader->attributes();
+  if (!m_XmlReader->hasError()) {
+    id_from = attributes.value("Id").toString().toStdString();
+  }
+
+  while (!m_XmlReader->isEndElement() || value != "LinkedFrom") { 
+    m_XmlReader->readNext();
+    value = m_XmlReader->qualifiedName().toString().toStdString();
+    if (m_XmlReader->isStartElement()) {
+      if (value == "LinkedTo") {
+        id_to = m_XmlReader->readElementText().toStdString();
+        if (!m_XmlReader->hasError()) {
+          m_Window->AddLink(id_from.c_str(), id_to.c_str(), false);
+        }
+      }
+    }
+  }
+  
+  return value;
+}
+//------------------------------------------------------------------------------
+
 //------------------------------------------------------------------------------
 void vvReadState::ReadGUI()
 {

diff --git a/vv/vvReadState.h b/vv/vvReadState.h
index 04607f68790bfa4261145f0526abf7b55a774502..a34c464cfa2bd17a7e0063ba5c54ee7ab50da967 100644 (file)
--- a/vv/vvReadState.h
+++ b/vv/vvReadState.h
@@ -27,6 +27,7 @@ protected:
   std::string ReadFusion(int index);
   std::string ReadOverlay(int index);
   std::string ReadVector(int index);
+  std::string ReadLink();
 
   std::auto_ptr<QXmlStreamReader> m_XmlReader;
   std::auto_ptr<QFile> m_File;

diff --git a/vv/vvSaveState.cxx b/vv/vvSaveState.cxx
index 71e22ef0cff854e7305484255b83e23a0e0deba1..ecf29da4b5939ff784f4b73eaa84a529ea7e8e61 100644 (file)
--- a/vv/vvSaveState.cxx
+++ b/vv/vvSaveState.cxx
@@ -72,6 +72,13 @@ void vvSaveState::SaveTree()
     SaveImage(item, i);
   }
   m_XmlWriter->writeEndElement();
+
+  m_XmlWriter->writeStartElement("Links");
+  for (int i = 0; i < tree->topLevelItemCount(); i++) {
+    const vvSlicerManager * slicerManager = m_Window->GetSlicerManagers()[i];
+    SaveLink(slicerManager);
+  }
+  m_XmlWriter->writeEndElement();
 }
 //------------------------------------------------------------------------------
 
@@ -82,14 +89,20 @@ void vvSaveState::SaveImage(const QTreeWidgetItem* item, int index)
   const vvSlicerManager * slicerManager = m_Window->GetSlicerManagers()[index];
   m_XmlWriter->writeStartElement("Image");
 
-  std::ostringstream indexStr;
-  indexStr.str("");
-  indexStr << index;
-  m_XmlWriter->writeAttribute("Index", indexStr.str().c_str());
+  std::ostringstream valueStr;
+  valueStr.str("");
+  valueStr << index;
+  m_XmlWriter->writeAttribute("Index", valueStr.str().c_str());
 
   std::string filename = item->data(0, Qt::UserRole).toString().toStdString();
   m_XmlWriter->writeTextElement("FileName", QDir::current().absoluteFilePath(filename.c_str()));
-
+  int preset = slicerManager->GetPreset();
+  m_XmlWriter->writeTextElement("Preset", QString::number(preset));
+  if (preset == 6) {
+    m_XmlWriter->writeTextElement("Window", QString::number(slicerManager->GetColorWindow()));
+    m_XmlWriter->writeTextElement("Level", QString::number(slicerManager->GetColorLevel()));
+  }
+  
   QTreeWidgetItem* item_child;
   std::string role;
   for (int i = 0; i < item->childCount(); i++) {
@@ -150,6 +163,24 @@ void vvSaveState::SaveVector(const QTreeWidgetItem* item)
 }
 //------------------------------------------------------------------------------
 
+//------------------------------------------------------------------------------
+void vvSaveState::SaveLink(const vvSlicerManager* vvManager)
+{
+  typedef std::list<std::string> LinkListType;
+  LinkListType links = vvManager->GetLinks();
+  if (!links.empty()) {
+    std::string my_id = vvManager->GetId();
+    m_XmlWriter->writeStartElement("LinkedFrom");
+    m_XmlWriter->writeAttribute("Id", my_id.c_str());
+    typename LinkListType::iterator i;
+    for (i = links.begin(); i != links.end(); i++) {
+      std::string link_id = *i;
+      m_XmlWriter->writeTextElement("LinkedTo", link_id.c_str());
+    }
+    m_XmlWriter->writeEndElement();
+  }
+}
+//------------------------------------------------------------------------------
 
 //------------------------------------------------------------------------------
 void vvSaveState::SaveGUI()

diff --git a/vv/vvSaveState.h b/vv/vvSaveState.h
index 29a0e405803fc64fbec339bd6c69dc2855e21132..4f96c063e15a61e413fa1bbb531422111603ff6f 100644 (file)
--- a/vv/vvSaveState.h
+++ b/vv/vvSaveState.h
@@ -28,6 +28,7 @@ protected:
   void SaveFusion(const QTreeWidgetItem* item, const vvSlicerManager* slicerManager);
   void SaveOverlay(const QTreeWidgetItem* item, const vvSlicerManager* slicerManager);
   void SaveVector(const QTreeWidgetItem* item);
+  void SaveLink(const vvSlicerManager* slicerManager);
 
   std::auto_ptr<QXmlStreamWriter> m_XmlWriter;
   std::auto_ptr<QFile> m_File;

diff --git a/vv/vvSlicer.cxx b/vv/vvSlicer.cxx
index 17aa41b81a9619b928a3268fea886d6d4c858fad..92463226aa392cb2bbd719dea9558e00eac8bc73 100644 (file)
--- a/vv/vvSlicer.cxx
+++ b/vv/vvSlicer.cxx
@@ -90,10 +90,10 @@ vvSlicer::vvSlicer()
   mCurrent[1] = -VTK_DOUBLE_MAX;
   mCurrent[2] = -VTK_DOUBLE_MAX;
 
-  mCursor[0] = -VTK_DOUBLE_MAX;
-  mCursor[1] = -VTK_DOUBLE_MAX;
-  mCursor[2] = -VTK_DOUBLE_MAX;
-  mCursor[3] = -VTK_DOUBLE_MAX;
+  mCursor[0] = 0;//-VTK_DOUBLE_MAX;
+  mCursor[1] = 0;//-VTK_DOUBLE_MAX;
+  mCursor[2] = 0;//-VTK_DOUBLE_MAX;
+  mCursor[3] = 0;//-VTK_DOUBLE_MAX;
 
   mSubSampling = 5;
   mScale = 1;
@@ -813,15 +813,22 @@ void vvSlicer::SetSliceOrientation(int orientation)
     AdjustResliceToSliceOrientation(mOverlayReslice);
 
   // Update the viewer
-  int *range = this->GetSliceRange();
-  if (range)
-    this->Slice = static_cast<int>((range[0] + range[1]) * 0.5);
-
+  
   // Go to current cursor position
   // double* cursorPos = GetCursorPosition();
   // DDV(cursorPos, 3);
   // SetCurrentPosition(cursorPos[0],cursorPos[1],cursorPos[2],cursorPos[3]);
 
+  if (this->Renderer && this->GetInput()) {
+    double s = mCursor[orientation];
+    double sCursor = (s - this->GetInput()->GetOrigin()[orientation])/this->GetInput()->GetSpacing()[orientation];
+    this->Slice = static_cast<int>(sCursor);
+  }
+  
+//   int *range = this->GetSliceRange();
+//   if (range)
+//     this->Slice = static_cast<int>((range[0] + range[1]) * 0.5);
+
   this->UpdateOrientation();
   this->UpdateDisplayExtent();
 

diff --git a/vv/vvSlicerManager.cxx b/vv/vvSlicerManager.cxx
index eb8977dd0548b890388f5cda415785e644d69ac1..9331bf1ab78a859dcfaf96c4b092c8f4ce3f7454 100644 (file)
--- a/vv/vvSlicerManager.cxx
+++ b/vv/vvSlicerManager.cxx
@@ -69,7 +69,8 @@ vvSlicerManager::vvSlicerManager(int numberOfSlicers)
 
   for ( int i = 0; i < numberOfSlicers; i++)
     mSlicers.push_back(vtkSmartPointer<vvSlicer>::New());
-
+  mSelectedSlicer = -1;
+  
   mPreviousSlice.resize(numberOfSlicers);
   mPreviousTSlice.resize(numberOfSlicers);
   mSlicingPreset = WORLD_SLICING;
@@ -605,6 +606,7 @@ void vvSlicerManager::UpdateViews(int current,int slicer)
       z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) {
     mSlicers[slicer]->UpdateCursorPosition();
     mSlicers[slicer]->SetCursorColor(10,212,255);
+    mSelectedSlicer = slicer;
 
     switch (mSlicers[slicer]->GetSliceOrientation()) {
     case vtkImageViewer2::SLICE_ORIENTATION_XY:
@@ -735,7 +737,7 @@ void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagat
 //----------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
-double vvSlicerManager::GetColorWindow()
+double vvSlicerManager::GetColorWindow() const
 {
   if (mSlicers.size())
     return mSlicers[0]->GetColorWindow();
@@ -745,7 +747,7 @@ double vvSlicerManager::GetColorWindow()
 
 
 //----------------------------------------------------------------------------
-double vvSlicerManager::GetColorLevel()
+double vvSlicerManager::GetColorLevel() const
 {
   if (mSlicers.size())
     return mSlicers[0]->GetColorLevel();

diff --git a/vv/vvSlicerManager.h b/vv/vvSlicerManager.h
index 088df6171a39d2fa7467b63ff42843d86e448271..dcac673216f1af7eef36b8394dfa32bb6dbbf8f9 100644 (file)
--- a/vv/vvSlicerManager.h
+++ b/vv/vvSlicerManager.h
@@ -86,6 +86,10 @@ class vvSlicerManager : public QObject {
   ///Switch between nearest neighbor and linear interpolation
   void ToggleInterpolation();
   vvSlicer* GetSlicer(int i);
+  int GetSelectedSlicer() {
+    return mSelectedSlicer;
+  }
+  
   void UpdateSlicer(int num, bool state);
   void SetSlicerWindow(int i, vtkRenderWindow* RW);
   void SetInteractorStyleNavigator(int i,vtkInteractorStyle* style);
@@ -95,7 +99,7 @@ class vvSlicerManager : public QObject {
   vvImage::Pointer GetVF()     { return mVF; }
   int GetType()                { return mType; }
   void SetId(std::string id)   { mId = id; }
-  std::string GetId()          { return mId; }
+  std::string GetId()  const        { return mId; }
   int GetDimension() {
     if (mImage) return mImage->GetNumberOfDimensions();
     else return -1;
@@ -142,15 +146,15 @@ class vvSlicerManager : public QObject {
     mFusionShowLegend = show;
   }
 
-  double GetColorWindow();
-  double GetColorLevel();
+  double GetColorWindow() const;
+  double GetColorLevel() const;
   double GetOverlayColorWindow() const;
   double GetOverlayColorLevel() const;
   bool GetLinkOverlayWindowLevel() const;
   int GetColorMap() {
     return mColorMap;
   }
-  int GetPreset() {
+  int GetPreset() const {
     return mPreset;
   }
   SlicingPresetType GetSlicingPreset() {
@@ -189,6 +193,10 @@ class vvSlicerManager : public QObject {
     mLinkedId.remove(oldId); 
   }
   
+  std::list<std::string> GetLinks() const {
+    return mLinkedId;
+  }
+  
   bool IsLinked() {
     return mLinkedId.size() > 0;
   }
@@ -240,6 +248,7 @@ signals :
 
 protected:
   std::vector< vtkSmartPointer<vvSlicer> > mSlicers;
+  int mSelectedSlicer;
   vvImageReader::Pointer mReader;
   vvImageReader::Pointer mOverlayReader;
   vvImageReader::Pointer mFusionReader;