Debug --contour while opening

[clitk.git] / vv / vvSlicerManager.cxx

diff --git a/vv/vvSlicerManager.cxx b/vv/vvSlicerManager.cxx
index d2bf5f2fc3f4437c376d877bad4ced81b868831f..82d6508bf8445eed080b45706bb645cac50efa4a 100644 (file)
--- a/vv/vvSlicerManager.cxx
+++ b/vv/vvSlicerManager.cxx
@@ -46,7 +46,10 @@
 #include <QMessageBox>\r
 //----------------------------------------------------------------------------\r
 vvSlicerManager::vvSlicerManager(int numberOfSlicers)\r
-{ //out << __func__ << endl;\r
+{ \r
+\r
+  connect(this, SIGNAL(callAddLandmark(float,float,float,float)), this, SLOT(AddLandmark(float,float,float,float)));\r
+\r
   mFileName = "";\r
   mId = "";\r
   mVFName = "";\r
@@ -76,8 +79,10 @@ vvSlicerManager::vvSlicerManager(int numberOfSlicers)
   mLandmarks = NULL;\r
   mLinkedId.resize(0);\r
 \r
-  for ( int i = 0; i < numberOfSlicers; i++)\r
+  for ( int i = 0; i < numberOfSlicers; i++) {\r
     mSlicers.push_back(vtkSmartPointer<vvSlicer>::New());\r
+    mSlicers[i]->SetSlicerNumber(i);\r
+  }\r
   mSelectedSlicer = -1;\r
   \r
   mPreviousSlice.resize(numberOfSlicers, 0);\r
@@ -91,7 +96,7 @@ vvSlicerManager::vvSlicerManager(int numberOfSlicers)
 \r
 //----------------------------------------------------------------------------\r
 vvSlicerManager::~vvSlicerManager()\r
-{ //out << __func__ << endl;\r
+{ \r
   if (mLandmarks)\r
     delete mLandmarks;\r
 }\r
@@ -100,7 +105,7 @@ vvSlicerManager::~vvSlicerManager()
 \r
 //------------------------------------------------------------------------------\r
 void vvSlicerManager::SetFilename(std::string filename, int number)\r
-{ //out << __func__ << endl;\r
+{ \r
   mFileName = filename;\r
   mFileName = vtksys::SystemTools::GetFilenameName(mFileName);\r
   mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));\r
@@ -122,7 +127,7 @@ void vvSlicerManager::SetFilename(std::string filename, int number)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::AddContour(vvMesh::Pointer contour,bool propagate)\r
-{ //out << __func__ << endl;\r
+{ \r
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
     mSlicers[i]->AddContour(contour,propagate);\r
   }\r
@@ -132,7 +137,7 @@ void vvSlicerManager::AddContour(vvMesh::Pointer contour,bool propagate)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::ToggleContourSuperposition()\r
-{ //out << __func__ << endl;\r
+{ \r
   for ( unsigned int i = 0; i < mSlicers.size(); i++)\r
     mSlicers[i]->ToggleContourSuperposition();\r
 }\r
@@ -140,7 +145,7 @@ void vvSlicerManager::ToggleContourSuperposition()
 \r
 //----------------------------------------------------------------------------\r
 std::string vvSlicerManager::GetListOfAbsoluteFilePathInOneString(const std::string &actorType)\r
-{ //out << __func__ << endl;\r
+{ \r
   vvImageReader *reader = NULL;\r
 \r
   if(actorType=="image")\r
@@ -171,7 +176,7 @@ std::string vvSlicerManager::GetListOfAbsoluteFilePathInOneString(const std::str
 \r
 //----------------------------------------------------------------------------\r
 bool vvSlicerManager::SetImage(std::string filename, vvImageReader::LoadedImageType type, int n, unsigned int slice)\r
-{ //out << __func__ << endl;\r
+{ \r
   mType = type;\r
   if (mReader.IsNull())\r
     mReader = vvImageReader::New();\r
@@ -206,7 +211,7 @@ bool vvSlicerManager::SetImage(std::string filename, vvImageReader::LoadedImageT
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetImage(vvImage::Pointer image)\r
-{ //out << __func__ << endl;\r
+{ \r
   mImage=image;\r
   for (unsigned int i = 0; i < mSlicers.size(); i++) {\r
     mSlicers[i]->SetImage(image);\r
@@ -217,7 +222,7 @@ void vvSlicerManager::SetImage(vvImage::Pointer image)
 \r
 //----------------------------------------------------------------------------\r
 bool vvSlicerManager::SetImages(std::vector<std::string> filenames, vvImageReader::LoadedImageType type, int n)\r
-{ //out << __func__ << endl;\r
+{ \r
   mType = type;\r
   std::string fileWithoutExtension = vtksys::SystemTools::GetFilenameWithoutExtension(filenames[0]);\r
   if (type == vvImageReader::DICOM)\r
@@ -257,7 +262,7 @@ bool vvSlicerManager::SetImages(std::vector<std::string> filenames, vvImageReade
 \r
 //----------------------------------------------------------------------------\r
 bool vvSlicerManager::SetOverlay(std::vector<std::string> filenames,int dim, std::string component, vvImageReader::LoadedImageType type)\r
-{ //out << __func__ << endl;\r
+{ \r
   mOverlayName = filenames[0];\r
   mOverlayComponent = component;\r
   if (dim > mImage->GetNumberOfDimensions()) {\r
@@ -283,7 +288,7 @@ bool vvSlicerManager::SetOverlay(std::vector<std::string> filenames,int dim, std
 \r
 //----------------------------------------------------------------------------\r
 bool vvSlicerManager::SetFusion(std::vector<std::string> filenames,int dim, std::string component, vvImageReader::LoadedImageType type)\r
-{ //out << __func__ << endl;\r
+{ \r
   mFusionName = filenames[0];\r
   mFusionComponent = component;\r
   if (dim > mImage->GetNumberOfDimensions()) {\r
@@ -313,7 +318,7 @@ bool vvSlicerManager::SetFusion(std::vector<std::string> filenames,int dim, std:
 //----------------------------------------------------------------------------\r
 //this function is called by vvMainWindow::AddFusionSequence for the primary sequence (CT), while the given files constitute the secondary sequence.\r
 bool vvSlicerManager::SetFusionSequence(std::vector<std::string> filenames, int dim, std::string component, vvImageReader::LoadedImageType type)\r
-{ //out << __func__ << endl;\r
+{ \r
        mFusionSequenceInvolvementCode = 0;\r
 \r
        mFusionName = filenames[0];\r
@@ -362,7 +367,7 @@ bool vvSlicerManager::SetFusionSequence(std::vector<std::string> filenames, int
 \r
 //----------------------------------------------------------------------------\r
 bool vvSlicerManager::SetVF(std::string filename)\r
-{ //out << __func__ << endl;\r
+{ \r
   if (mVectorReader.IsNull())\r
     mVectorReader = vvImageReader::New();\r
   mVectorReader->SetInputFilename(filename);\r
@@ -382,7 +387,7 @@ bool vvSlicerManager::SetVF(std::string filename)
 \r
 //----------------------------------------------------------------------------\r
 bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename)\r
-{ //out << __func__ << endl;\r
+{ \r
   if (vf->GetNumberOfDimensions() > mImage->GetNumberOfDimensions()) {\r
     mLastError = "Sorry, vector field dimension cannot be greater then reference image.";\r
     return false;\r
@@ -409,7 +414,7 @@ bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename)
 \r
 //----------------------------------------------------------------------------\r
 vvSlicer* vvSlicerManager::GetSlicer(int i)\r
-{ //out << __func__ << endl;\r
+{ \r
   return mSlicers[i];\r
 }\r
 //----------------------------------------------------------------------------\r
@@ -417,7 +422,7 @@ vvSlicer* vvSlicerManager::GetSlicer(int i)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::UpdateSlicer(int num, bool state)\r
-{ //out << __func__ << endl;\r
+{ \r
   if (mSlicers[num]->GetImage()) {\r
     mSlicers[num]->SetDisplayMode(state);\r
   }\r
@@ -427,7 +432,7 @@ void vvSlicerManager::UpdateSlicer(int num, bool state)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW)\r
-{ //out << __func__ << endl;\r
+{ \r
   mSlicers[i]->SetRenderWindow(i,RW);\r
 }\r
 //----------------------------------------------------------------------------\r
@@ -435,7 +440,7 @@ void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* style)\r
-{ //out << __func__ << endl;\r
+{ \r
   vvSlicerManagerCommand *smc = vvSlicerManagerCommand::New();\r
   smc->SM = this;\r
   smc->SetSlicerNumber(i);\r
@@ -474,7 +479,7 @@ void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* sty
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::LeftButtonReleaseEvent(int slicer)\r
-{ //out << __func__ << endl;\r
+{ \r
   emit LeftButtonReleaseSignal(slicer);\r
 }\r
 //----------------------------------------------------------------------------\r
@@ -482,7 +487,7 @@ void vvSlicerManager::LeftButtonReleaseEvent(int slicer)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::EmitMousePositionUpdated(int slicer)\r
-{ //out << __func__ << endl;\r
+{ \r
   emit MousePositionUpdatedSignal(slicer);\r
 }\r
 //----------------------------------------------------------------------------\r
@@ -490,7 +495,7 @@ void vvSlicerManager::EmitMousePositionUpdated(int slicer)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::EmitKeyPressed(std::string KeyPress)\r
-{ //out << __func__ << endl;\r
+{ \r
   emit KeyPressedSignal(KeyPress);\r
 }\r
 //----------------------------------------------------------------------------\r
@@ -498,7 +503,7 @@ void vvSlicerManager::EmitKeyPressed(std::string KeyPress)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetSliceOrientation(int slicer, int orientation)\r
-{ //out << __func__ << endl;\r
+{ \r
   mSlicers[slicer]->SetSliceOrientation(orientation);\r
   emit UpdateOrientation(slicer, orientation);\r
 }\r
@@ -506,14 +511,14 @@ void vvSlicerManager::SetSliceOrientation(int slicer, int orientation)
 \r
 //----------------------------------------------------------------------------\r
 int vvSlicerManager::GetTSlice()\r
-{ //out << __func__ << endl;\r
+{ \r
   return mSlicers[0]->GetTSlice();\r
 }\r
 //----------------------------------------------------------------------------\r
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetTSlice(int slice, bool updateLinkedImages)\r
-{ //out << __func__ << endl;\r
+{ \r
        if (!updateLinkedImages) { //for fusionSequence, TMax / MaxCurrentTSlice are irrelevant.\r
                for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
                        mSlicers[i]->SetTSlice(slice, updateLinkedImages);\r
@@ -540,7 +545,7 @@ void vvSlicerManager::SetTSlice(int slice, bool updateLinkedImages)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetFusionSequenceTSlice(int slice)\r
-{ //out << __func__ << endl;\r
+{ \r
        for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
                mSlicers[i]->SetFusionSequenceTSlice(slice);\r
                UpdateTSlice(i);\r
@@ -551,7 +556,7 @@ void vvSlicerManager::SetFusionSequenceTSlice(int slice)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetNextTSlice(int originating_slicer)\r
-{ //out << __func__ << endl;\r
+{ \r
   int t = mSlicers[0]->GetMaxCurrentTSlice();\r
   t++;\r
   if (t > mSlicers[0]->GetTMax())\r
@@ -563,7 +568,7 @@ void vvSlicerManager::SetNextTSlice(int originating_slicer)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetPreviousTSlice(int originating_slicer)\r
-{ //out << __func__ << endl;\r
+{ \r
   int t = mSlicers[0]->GetMaxCurrentTSlice();\r
   t--;\r
   if (t < 0)\r
@@ -575,7 +580,7 @@ void vvSlicerManager::SetPreviousTSlice(int originating_slicer)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::ToggleInterpolation()\r
-{ //out << __func__ << endl;\r
+{ \r
   bool interpolate=!(mSlicers[0]->GetImageActor()->GetInterpolate());\r
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
     mSlicers[i]->GetImageActor()->SetInterpolate(interpolate);\r
@@ -590,7 +595,7 @@ void vvSlicerManager::ToggleInterpolation()
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)\r
-{ //out << __func__ << endl;\r
+{ \r
   if (tslice < 0)\r
     tslice = 0;\r
   else if (tslice > mSlicers[slicer]->GetTMax())\r
@@ -616,7 +621,7 @@ void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetColorWindow(double s)\r
-{ //out << __func__ << endl;\r
+{ \r
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
     mSlicers[i]->SetColorWindow(s);\r
   }\r
@@ -625,7 +630,7 @@ void vvSlicerManager::SetColorWindow(double s)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetColorLevel(double s)\r
-{ //out << __func__ << endl;\r
+{ \r
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
     mSlicers[i]->SetColorLevel(s);\r
   }\r
@@ -634,7 +639,7 @@ void vvSlicerManager::SetColorLevel(double s)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetOverlayColorWindow(double s)\r
-{ //out << __func__ << endl;\r
+{ \r
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
     mSlicers[i]->SetOverlayColorWindow(s);\r
   }\r
@@ -643,7 +648,7 @@ void vvSlicerManager::SetOverlayColorWindow(double s)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetOverlayColorLevel(double s)\r
-{ //out << __func__ << endl;\r
+{ \r
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
     mSlicers[i]->SetOverlayColorLevel(s);\r
   }\r
@@ -652,7 +657,7 @@ void vvSlicerManager::SetOverlayColorLevel(double s)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetLinkOverlayWindowLevel(bool b)\r
-{ //out << __func__ << endl;\r
+{ \r
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
     mSlicers[i]->SetLinkOverlayWindowLevel(b);\r
   }\r
@@ -661,7 +666,7 @@ void vvSlicerManager::SetLinkOverlayWindowLevel(bool b)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetCursorAndCornerAnnotationVisibility(int s)\r
-{ //out << __func__ << endl;\r
+{ \r
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
     mSlicers[i]->SetCursorVisibility(s);\r
     mSlicers[i]->SetCornerAnnotationVisibility(s);\r
@@ -671,7 +676,7 @@ void vvSlicerManager::SetCursorAndCornerAnnotationVisibility(int s)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetOpacity(int i, double factor)\r
-{ //out << __func__ << endl;\r
+{ \r
   mSlicers[i]->SetOpacity(1/factor);\r
 }\r
 //----------------------------------------------------------------------------\r
@@ -679,7 +684,7 @@ void vvSlicerManager::SetOpacity(int i, double factor)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::UpdateViews(int current,int slicer)\r
-{ //out << __func__ << endl;\r
+{ \r
   double p[3], pt[3];\r
   p[0] = mSlicers[slicer]->GetCurrentPosition()[0];\r
   p[1] = mSlicers[slicer]->GetCurrentPosition()[1];\r
@@ -835,7 +840,7 @@ mSlicers[slicer]->GetRegisterExtent(extentImageReslice);
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::UpdateLinked(int slicer)\r
-{ //out << __func__ << endl;\r
+{ \r
   double p[3], pt[3];\r
   p[0] = mSlicers[slicer]->GetCurrentPosition()[0];\r
   p[1] = mSlicers[slicer]->GetCurrentPosition()[1];\r
@@ -886,7 +891,7 @@ mSlicers[slicer]->GetRegisterExtent(extentImageReslice);
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate)\r
-{ //out << __func__ << endl;\r
+{ \r
   vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera();\r
 \r
   double refPosition[3];\r
@@ -929,7 +934,7 @@ void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagat
 \r
 //----------------------------------------------------------------------------\r
 double vvSlicerManager::GetColorWindow() const\r
-{ //out << __func__ << endl;\r
+{ \r
   if (mSlicers.size())\r
     return mSlicers[0]->GetColorWindow();\r
   return -1;\r
@@ -939,7 +944,7 @@ double vvSlicerManager::GetColorWindow() const
 \r
 //----------------------------------------------------------------------------\r
 double vvSlicerManager::GetColorLevel() const\r
-{ //out << __func__ << endl;\r
+{ \r
   if (mSlicers.size())\r
     return mSlicers[0]->GetColorLevel();\r
   return -1;\r
@@ -948,7 +953,7 @@ double vvSlicerManager::GetColorLevel() const
 \r
 //----------------------------------------------------------------------------\r
 double vvSlicerManager::GetOverlayColorWindow() const\r
-{ //out << __func__ << endl;\r
+{ \r
   if (mSlicers.size())\r
     return mSlicers[0]->GetOverlayColorWindow();\r
   return -1;\r
@@ -957,7 +962,7 @@ double vvSlicerManager::GetOverlayColorWindow() const
 \r
 //----------------------------------------------------------------------------\r
 double vvSlicerManager::GetOverlayColorLevel() const\r
-{ //out << __func__ << endl;\r
+{ \r
   if (mSlicers.size())\r
     return mSlicers[0]->GetOverlayColorLevel();\r
   return -1;\r
@@ -966,7 +971,7 @@ double vvSlicerManager::GetOverlayColorLevel() const
 \r
 //----------------------------------------------------------------------------\r
 bool vvSlicerManager::GetLinkOverlayWindowLevel() const\r
-{ //out << __func__ << endl;\r
+{ \r
   if (mSlicers.size())\r
     return mSlicers[0]->GetLinkOverlayWindowLevel();\r
   return -1;\r
@@ -975,7 +980,7 @@ bool vvSlicerManager::GetLinkOverlayWindowLevel() const
 \r
 //------------------------------------------------------------------------------\r
 void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType)\r
-{ //out << __func__ << endl;\r
+{ \r
   if(actorType == "image")\r
     for(unsigned int i=0; i<this->GetImage()->GetTransform().size(); i++)\r
       this->GetImage()->GetTransform()[i]->Identity();\r
@@ -1004,7 +1009,7 @@ void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::Render()\r
-{ //out << __func__ << endl;\r
+{ \r
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
     mSlicers[i]->Render();\r
   }\r
@@ -1014,7 +1019,7 @@ void vvSlicerManager::Render()
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::GenerateDefaultLookupTable()\r
-{ //out << __func__ << endl;\r
+{ \r
   SetPreset(mPreset);\r
   SetColorMap(mColorMap);\r
 }\r
@@ -1023,7 +1028,7 @@ void vvSlicerManager::GenerateDefaultLookupTable()
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::Reload()\r
-{ //out << __func__ << endl;\r
+{ \r
   mReader->Update(mType);\r
   mImage=mReader->GetOutput();\r
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
@@ -1040,7 +1045,7 @@ void vvSlicerManager::Reload()
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::ReloadFusion()\r
-{ //out << __func__ << endl;\r
+{ \r
   mFusionReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),mType);\r
 \r
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
@@ -1053,7 +1058,7 @@ void vvSlicerManager::ReloadFusion()
 //----------------------------------------------------------------------------\r
 //the secondary sequence is being reloaded.\r
 void vvSlicerManager::ReloadFusionSequence()\r
-{ //out << __func__ << endl;\r
+{ \r
   //  this is to keep the slice thickness, which needs to be artificially increased for visualization\r
   double sp_x, sp_y, sp_z;\r
   this->GetImage()->GetVTKImages()[0]->GetSpacing(sp_x, sp_y, sp_z);\r
@@ -1090,7 +1095,7 @@ void vvSlicerManager::ReloadFusionSequence()
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::ReloadOverlay()\r
-{ //out << __func__ << endl;\r
+{ \r
   mOverlayReader->Update(mImage->GetNumberOfDimensions(),mOverlayComponent.c_str(),mType);\r
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
     mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());\r
@@ -1102,7 +1107,7 @@ void vvSlicerManager::ReloadOverlay()
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::ReloadVF()\r
-{ //out << __func__ << endl;\r
+{ \r
   mVectorReader->Update(vvImageReader::VECTORFIELD); //deletes the old images through the VF::Init() function\r
   mVF=mVectorReader->GetOutput();\r
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
@@ -1115,7 +1120,7 @@ void vvSlicerManager::ReloadVF()
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)\r
-{ //out << __func__ << endl;\r
+{ \r
   if (actor_type =="overlay")\r
     mOverlayReader = NULL;\r
 \r
@@ -1139,7 +1144,7 @@ void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_ind
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::RemoveActors()\r
-{ //out << __func__ << endl;\r
+{ \r
   ///This method leaks a few objects. See RemoveActor for what a\r
   ///correct implementation would look like\r
   //DS -> probably due to the reader (now released in the\r
@@ -1154,7 +1159,7 @@ void vvSlicerManager::RemoveActors()
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)\r
-{ //out << __func__ << endl;\r
+{ \r
   //  int view = mSlicers[slicer]->GetSliceOrientation();\r
   //  int slice = mSlicers[slicer]->GetSlice();\r
   double x = mSlicers[slicer]->GetCursorPosition()[0];\r
@@ -1301,7 +1306,7 @@ mSlicers[slicer]->GetRegisterExtent(extentImageReslice);
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::Activated()\r
-{ //out << __func__ << endl;\r
+{ \r
   emit currentImageChanged(mId);\r
 }\r
 //----------------------------------------------------------------------------\r
@@ -1309,7 +1314,7 @@ void vvSlicerManager::Activated()
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::Picked()\r
-{ //out << __func__ << endl;\r
+{ \r
   emit currentPickedImageChanged(mId);\r
 }\r
 //----------------------------------------------------------------------------\r
@@ -1317,7 +1322,7 @@ void vvSlicerManager::Picked()
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::UpdateWindowLevel()\r
-{ //out << __func__ << endl;\r
+{ \r
   emit WindowLevelChanged();\r
 }\r
 //----------------------------------------------------------------------------\r
@@ -1325,7 +1330,7 @@ void vvSlicerManager::UpdateWindowLevel()
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::UpdateSlice(int slicer)\r
-{ //out << __func__ << endl;\r
+{ \r
   if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {\r
     //DD("============= NOTHING");\r
     return;\r
@@ -1339,7 +1344,7 @@ void vvSlicerManager::UpdateSlice(int slicer)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::UpdateTSlice(int slicer)\r
-{ //out << __func__ << endl;\r
+{ \r
   int slice = mSlicers[slicer]->GetSlice();\r
 \r
   int tslice = mSlicers[slicer]->GetMaxCurrentTSlice();\r
@@ -1361,7 +1366,7 @@ void vvSlicerManager::UpdateTSlice(int slicer)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::UpdateSliceRange(int slicer)\r
-{ //out << __func__ << endl;\r
+{ \r
   emit UpdateSliceRange(slicer,\r
                         mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],\r
                         0,mSlicers[slicer]->GetTMax());\r
@@ -1370,7 +1375,7 @@ void vvSlicerManager::UpdateSliceRange(int slicer)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetSlicingPreset(SlicingPresetType preset)\r
-{ //out << __func__ << endl;\r
+{ \r
   if(mSlicingPreset==preset)\r
     return;\r
 \r
@@ -1413,7 +1418,7 @@ void vvSlicerManager::SetSlicingPreset(SlicingPresetType preset)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetPreset(int preset)\r
-{ //out << __func__ << endl;\r
+{ \r
 \r
   //vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());\r
   double window = mSlicers[0]->GetColorWindow();\r
@@ -1472,7 +1477,7 @@ void vvSlicerManager::SetPreset(int preset)
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlKey)\r
-{ //out << __func__ << endl;\r
+{ \r
   double min, max;\r
   if(bCtrlKey && this->mSlicers[slicer]->GetFusion()) {\r
     int t = mSlicers[slicer]->GetFusionTSlice();\r
@@ -1513,7 +1518,7 @@ void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlK
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::SetColorMap(int colormap)\r
-{ //out << __func__ << endl;\r
+{ \r
   double range[2];\r
 \r
   range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];\r
@@ -1667,7 +1672,7 @@ void vvSlicerManager::SetColorMap(int colormap)
 \r
 //----------------------------------------------------------------------------\r
 vvLandmarks* vvSlicerManager::GetLandmarks()\r
-{ //out << __func__ << endl;\r
+{ \r
   if (mLandmarks == NULL) {\r
     mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);\r
     for (unsigned int i = 0; i < mSlicers.size(); i++)\r
@@ -1676,11 +1681,14 @@ vvLandmarks* vvSlicerManager::GetLandmarks()
   return mLandmarks;\r
 }\r
 //----------------------------------------------------------------------------\r
-\r
+void vvSlicerManager::AddNewLandmark(float x,float y,float z,float t)\r
+{ \r
+    emit callAddLandmark(x,y,z,t);\r
+}\r
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::AddLandmark(float x,float y,float z,float t)\r
-{ //out << __func__ << endl;\r
+{ \r
   double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];\r
   double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];\r
   double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];\r
@@ -1704,7 +1712,7 @@ void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
       y_index <= extentImageReslice[3]+0.5 &&\r
       z_index >= extentImageReslice[4]-0.5 &&\r
       z_index <= extentImageReslice[5]+0.5) {\r
-    double value = this->GetScalarComponentAsDouble(mSlicers[0]->GetInput(), x_index, y_index, z_index);\r
+    double value = this->GetScalarComponentAsDouble(mImage->GetVTKImages()[mSlicers[0]->GetTSlice()], x_index, y_index, z_index);\r
     this->GetLandmarks()->AddLandmark(x,y,z,t,value);\r
     emit LandmarkAdded();\r
   }\r
@@ -1712,23 +1720,55 @@ void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
 }\r
 //----------------------------------------------------------------------------\r
 \r
+//----------------------------------------------------------------------------\r
+void vvSlicerManager::AddLandmarkProfile(float x,float y,float z,float t)\r
+{ \r
+  double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];\r
+  double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];\r
+  double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];\r
+#if VTK_MAJOR_VERSION <= 5\r
+  if (x_index >= mSlicers[0]->GetInput()->GetWholeExtent()[0]-0.5 &&\r
+      x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1]+0.5 &&\r
+      y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2]-0.5 &&\r
+      y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3]+0.5 &&\r
+      z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4]-0.5 &&\r
+      z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]+0.5) {\r
+    double value = this->GetScalarComponentAsDouble(mSlicers[0]->GetInput(), x_index, y_index, z_index);\r
+    this->GetLandmarks()->AddLandmark(x,y,z,t,value);\r
+  }\r
+#else\r
+  int extentImageReslice[6];\r
+  mSlicers[0]->GetRegisterExtent(extentImageReslice);\r
+  if (x_index >= extentImageReslice[0]-0.5 &&\r
+      x_index <= extentImageReslice[1]+0.5 &&\r
+      y_index >= extentImageReslice[2]-0.5 &&\r
+      y_index <= extentImageReslice[3]+0.5 &&\r
+      z_index >= extentImageReslice[4]-0.5 &&\r
+      z_index <= extentImageReslice[5]+0.5) {\r
+    double value = this->GetScalarComponentAsDouble(mImage->GetVTKImages()[mSlicers[0]->GetTSlice()], x_index, y_index, z_index);\r
+    this->GetLandmarks()->AddLandmark(x,y,z,t,value);\r
+  }\r
+#endif\r
+}\r
+//----------------------------------------------------------------------------\r
+\r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::PrevImage(int slicer)\r
-{ //out << __func__ << endl;\r
+{ \r
   emit ChangeImageWithIndexOffset(this, slicer, -1);\r
 }\r
 //----------------------------------------------------------------------------\r
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::NextImage(int slicer)\r
-{ //out << __func__ << endl;\r
+{ \r
   emit ChangeImageWithIndexOffset(this, slicer,  1);\r
 }\r
 //----------------------------------------------------------------------------\r
 \r
 //----------------------------------------------------------------------------\r
 void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice)\r
-{ //out << __func__ << endl;\r
+{ \r
   emit AVerticalSliderHasChanged(slicer, slice);\r
 }\r
 \r
@@ -1736,7 +1776,7 @@ void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice)
 \r
 //----------------------------------------------------------------------------\r
 double vvSlicerManager::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int component)\r
-{ //out << __func__ << endl;\r
+{ \r
   int ix, iy, iz;\r
   return mSlicers[0]->GetScalarComponentAsDouble(image, X, Y, Z, ix, iy, iz, component);\r
 }\r