#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
\r
//----------------------------------------------------------------------------\r
vvSlicerManager::~vvSlicerManager()\r
-{ //out << __func__ << endl;\r
+{ \r
if (mLandmarks)\r
delete mLandmarks;\r
}\r
\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
\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
\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
\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
\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
\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
\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
\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
\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
//----------------------------------------------------------------------------\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
\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
\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
\r
//----------------------------------------------------------------------------\r
vvSlicer* vvSlicerManager::GetSlicer(int i)\r
-{ //out << __func__ << endl;\r
+{ \r
return mSlicers[i];\r
}\r
//----------------------------------------------------------------------------\r
\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
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW)\r
-{ //out << __func__ << endl;\r
+{ \r
mSlicers[i]->SetRenderWindow(i,RW);\r
}\r
//----------------------------------------------------------------------------\r
\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
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::LeftButtonReleaseEvent(int slicer)\r
-{ //out << __func__ << endl;\r
+{ \r
emit LeftButtonReleaseSignal(slicer);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::EmitMousePositionUpdated(int slicer)\r
-{ //out << __func__ << endl;\r
+{ \r
emit MousePositionUpdatedSignal(slicer);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::EmitKeyPressed(std::string KeyPress)\r
-{ //out << __func__ << endl;\r
+{ \r
emit KeyPressedSignal(KeyPress);\r
}\r
//----------------------------------------------------------------------------\r
\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
\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
\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
\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
\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
\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
\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
\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
\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
\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
\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
\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
\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
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetOpacity(int i, double factor)\r
-{ //out << __func__ << endl;\r
+{ \r
mSlicers[i]->SetOpacity(1/factor);\r
}\r
//----------------------------------------------------------------------------\r
\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
\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
\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
\r
//----------------------------------------------------------------------------\r
double vvSlicerManager::GetColorWindow() const\r
-{ //out << __func__ << endl;\r
+{ \r
if (mSlicers.size())\r
return mSlicers[0]->GetColorWindow();\r
return -1;\r
\r
//----------------------------------------------------------------------------\r
double vvSlicerManager::GetColorLevel() const\r
-{ //out << __func__ << endl;\r
+{ \r
if (mSlicers.size())\r
return mSlicers[0]->GetColorLevel();\r
return -1;\r
\r
//----------------------------------------------------------------------------\r
double vvSlicerManager::GetOverlayColorWindow() const\r
-{ //out << __func__ << endl;\r
+{ \r
if (mSlicers.size())\r
return mSlicers[0]->GetOverlayColorWindow();\r
return -1;\r
\r
//----------------------------------------------------------------------------\r
double vvSlicerManager::GetOverlayColorLevel() const\r
-{ //out << __func__ << endl;\r
+{ \r
if (mSlicers.size())\r
return mSlicers[0]->GetOverlayColorLevel();\r
return -1;\r
\r
//----------------------------------------------------------------------------\r
bool vvSlicerManager::GetLinkOverlayWindowLevel() const\r
-{ //out << __func__ << endl;\r
+{ \r
if (mSlicers.size())\r
return mSlicers[0]->GetLinkOverlayWindowLevel();\r
return -1;\r
\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
\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
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::GenerateDefaultLookupTable()\r
-{ //out << __func__ << endl;\r
+{ \r
SetPreset(mPreset);\r
SetColorMap(mColorMap);\r
}\r
\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
\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
//----------------------------------------------------------------------------\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
\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
\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
\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
\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
\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
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::Activated()\r
-{ //out << __func__ << endl;\r
+{ \r
emit currentImageChanged(mId);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::Picked()\r
-{ //out << __func__ << endl;\r
+{ \r
emit currentPickedImageChanged(mId);\r
}\r
//----------------------------------------------------------------------------\r
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::UpdateWindowLevel()\r
-{ //out << __func__ << endl;\r
+{ \r
emit WindowLevelChanged();\r
}\r
//----------------------------------------------------------------------------\r
\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
\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
\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
\r
//----------------------------------------------------------------------------\r
void vvSlicerManager::SetSlicingPreset(SlicingPresetType preset)\r
-{ //out << __func__ << endl;\r
+{ \r
if(mSlicingPreset==preset)\r
return;\r
\r
\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
\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
\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
\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
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
}\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
\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