#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
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
\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
y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&\r
y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&\r
z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&\r
- z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) {\r
- mSlicers[slicer]->UpdateCursorPosition();\r
- mSlicers[slicer]->SetCursorColor(10,212,255);\r
- mSelectedSlicer = slicer;\r
-\r
- switch (mSlicers[slicer]->GetSliceOrientation()) {\r
- case vtkImageViewer2::SLICE_ORIENTATION_XY:\r
- if (mSlicers[slicer]->GetSlice() != (int)lrint(z))\r
- mSlicers[slicer]->SetSlice((int)lrint(z));\r
- break;\r
-\r
- case vtkImageViewer2::SLICE_ORIENTATION_XZ:\r
- if (mSlicers[slicer]->GetSlice() != (int)lrint(y))\r
- mSlicers[slicer]->SetSlice((int)lrint(y));\r
- break;\r
-\r
- case vtkImageViewer2::SLICE_ORIENTATION_YZ:\r
- if (mSlicers[slicer]->GetSlice() != (int)lrint(x))\r
- mSlicers[slicer]->SetSlice((int)lrint(x));\r
- break;\r
- }\r
- mSlicers[slicer]->Render();\r
-\r
- for ( unsigned int i = 0; i < mSlicers.size(); i++) {\r
- if (i != (unsigned int)slicer\r
- && mSlicers[i]->GetRenderer()->GetDraw()\r
- && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2\r
- && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2) {\r
- mSlicers[i]->SetCurrentPosition(p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());\r
- mSlicers[i]->UpdateCursorPosition();\r
- if (current) { //do not display corner annotation if image is the one picked\r
- mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,\r
- -VTK_DOUBLE_MAX, mSlicers[slicer]->GetMaxCurrentTSlice());\r
- mSlicers[i]->SetCursorColor(255,10,212);\r
- } else {\r
- mSlicers[i]->SetCursorColor(150,10,282);\r
- }\r
- switch (mSlicers[i]->GetSliceOrientation()) {\r
- case vtkImageViewer2::SLICE_ORIENTATION_XY:\r
- if (mSlicers[i]->GetSlice() != (int)lrint(z))\r
- mSlicers[i]->SetSlice((int)lrint(z));\r
- break;\r
-\r
- case vtkImageViewer2::SLICE_ORIENTATION_XZ:\r
- if (mSlicers[i]->GetSlice() != (int)lrint(y))\r
- mSlicers[i]->SetSlice((int)lrint(y));\r
- break;\r
-\r
- case vtkImageViewer2::SLICE_ORIENTATION_YZ:\r
- if (mSlicers[i]->GetSlice() != (int)lrint(x))\r
- mSlicers[i]->SetSlice((int)lrint(x));\r
- break;\r
- }\r
- \r
- mSlicers[i]->Render();\r
- \r
- UpdateSlice(i);\r
- UpdateTSlice(i);\r
- }\r
- }\r
- }\r
+ z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5)\r
#else\r
int extentImageReslice[6];\r
mSlicers[slicer]->GetRegisterExtent(extentImageReslice);\r
y >= extentImageReslice[2]-0.5 &&\r
y <= extentImageReslice[3]+0.5 &&\r
z >= extentImageReslice[4]-0.5 &&\r
- z <= extentImageReslice[5]+0.5) {\r
+ z <= extentImageReslice[5]+0.5)\r
+#endif\r
+ {\r
mSlicers[slicer]->UpdateCursorPosition();\r
mSlicers[slicer]->SetCursorColor(10,212,255);\r
mSelectedSlicer = slicer;\r
}\r
}\r
}\r
-#endif\r
}\r
//----------------------------------------------------------------------------\r
\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
y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 &&\r
y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 &&\r
z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 &&\r
- z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) {\r
- for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) {\r
- if (this->IsInvolvedInFusionSequence()) {\r
- //this SlicerManager is involved in fusionSequence => do not synchronize the times\r
- emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], -1);\r
- }\r
- else {\r
- emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice());\r
- }\r
- }\r
- }\r
+ z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5)\r
#else\r
int extentImageReslice[6];\r
mSlicers[slicer]->GetRegisterExtent(extentImageReslice);\r
y >= extentImageReslice[2]-0.5 &&\r
y <= extentImageReslice[3]+0.5 &&\r
z >= extentImageReslice[4]-0.5 &&\r
- z <= extentImageReslice[5]+0.5) {\r
+ z <= extentImageReslice[5]+0.5)\r
+#endif\r
+ {\r
for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) {\r
if (this->IsInvolvedInFusionSequence()) {\r
//this SlicerManager is involved in fusionSequence => do not synchronize the times\r
}\r
}\r
}\r
-#endif\r
}\r
//----------------------------------------------------------------------------\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
mSlicers[slicer]->GetInput()->GetSpacing()[1];\r
double Z = (z - mSlicers[slicer]->GetInput()->GetOrigin()[2])/\r
mSlicers[slicer]->GetInput()->GetSpacing()[2];\r
+ double xyz[3], xyzTransform[3];\r
+ xyz[0] = x;\r
+ xyz[1] = y;\r
+ xyz[2] = z;\r
+ mSlicers[slicer]->GetConcatenatedTransform()->TransformPoint(xyz, xyzTransform);\r
+ double XTransform = (xyzTransform[0] - mSlicers[slicer]->GetImage()->GetVTKImages()[GetTSlice()]->GetOrigin()[0])/\r
+ mSlicers[slicer]->GetImage()->GetVTKImages()[GetTSlice()]->GetSpacing()[0];\r
+ double YTransform = (xyzTransform[1] - mSlicers[slicer]->GetImage()->GetVTKImages()[GetTSlice()]->GetOrigin()[1])/\r
+ mSlicers[slicer]->GetImage()->GetVTKImages()[GetTSlice()]->GetSpacing()[1];\r
+ double ZTransform = (xyzTransform[2] - mSlicers[slicer]->GetImage()->GetVTKImages()[GetTSlice()]->GetOrigin()[2])/\r
+ mSlicers[slicer]->GetImage()->GetVTKImages()[GetTSlice()]->GetSpacing()[2];\r
double value = -VTK_DOUBLE_MAX;\r
int displayVec = 0;\r
double xVec=0, yVec=0, zVec=0, valueVec=0;\r
int displayFus = 0;\r
double valueOver=0, valueFus=0;\r
#if VTK_MAJOR_VERSION <= 5\r
- if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&\r
- X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&\r
- Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&\r
- Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&\r
- Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&\r
- Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {\r
-\r
- value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z);\r
-\r
- if (mSlicers[slicer]->GetVFActor() ) {\r
- displayVec = 1;\r
- unsigned int currentTime = mSlicers[slicer]->GetMaxCurrentTSlice();\r
- vtkImageData *vf = NULL;\r
-\r
- if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)\r
- vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];\r
- else\r
- vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];\r
-\r
- if (vf) {\r
- double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];\r
- double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];\r
- double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];\r
- xVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 0);\r
- yVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 1);\r
- zVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 2);\r
- valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);\r
- }\r
- }\r
- if (mSlicers[slicer]->GetOverlayActor() ) {\r
- displayOver = 1;\r
- vtkImageData *overlay = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput());\r
- double Xover = (x - overlay->GetOrigin()[0]) / overlay->GetSpacing()[0];\r
- double Yover = (y - overlay->GetOrigin()[1]) / overlay->GetSpacing()[1];\r
- double Zover = (z - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2];\r
- valueOver = this->GetScalarComponentAsDouble(overlay, Xover, Yover, Zover);\r
- }\r
-\r
- if ( mSlicers[slicer]->GetFusionActor() ) {\r
- displayFus = 1;\r
- vtkImageData *fusion = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput());\r
- double Xover = (x - fusion->GetOrigin()[0]) / fusion->GetSpacing()[0];\r
- double Yover = (y - fusion->GetOrigin()[1]) / fusion->GetSpacing()[1];\r
- double Zover = (z - fusion->GetOrigin()[2]) / fusion->GetSpacing()[2];\r
- valueFus = this->GetScalarComponentAsDouble(fusion, Xover, Yover, Zover);\r
- }\r
- else if (this->IsInvolvedInFusionSequence()) { \r
- //if the cursor moves over the 'independent' version of the secondary sequence\r
- //do not update the panel, just keep it as it is.\r
- displayFus = 1;\r
- valueFus = std::numeric_limits<double>::quiet_NaN();\r
- }\r
-\r
- emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),\r
- x,y,z,X,Y,Z,value);\r
- emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);\r
- emit UpdateOverlay(displayOver,valueOver,value);\r
- emit UpdateFusion(displayFus,valueFus);\r
- }\r
+ if (XTransform >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] -0.5 &&\r
+ XTransform <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] +0.5 &&\r
+ YTransform >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] -0.5 &&\r
+ YTransform <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] +0.5 &&\r
+ ZTransform >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] -0.5 &&\r
+ ZTransform <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5] +0.5)\r
#else\r
int extentImageReslice[6];\r
mSlicers[slicer]->GetRegisterExtent(extentImageReslice);\r
- if (X >= extentImageReslice[0] &&\r
- X <= extentImageReslice[1] &&\r
- Y >= extentImageReslice[2] &&\r
- Y <= extentImageReslice[3] &&\r
- Z >= extentImageReslice[4] &&\r
- Z <= extentImageReslice[5]) {\r
-\r
+ if (XTransform >= extentImageReslice[0] -0.5 &&\r
+ XTransform <= extentImageReslice[1] +0.5 &&\r
+ YTransform >= extentImageReslice[2] -0.5 &&\r
+ YTransform <= extentImageReslice[3] +0.5 &&\r
+ ZTransform >= extentImageReslice[4] -0.5 &&\r
+ ZTransform <= extentImageReslice[5] +0.5)\r
+#endif\r
+ {\r
value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z);\r
\r
if (mSlicers[slicer]->GetVFActor() ) {\r
}\r
\r
emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),\r
- x,y,z,X,Y,Z,value);\r
+ x,y,z,XTransform,YTransform,ZTransform,value);\r
emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);\r
emit UpdateOverlay(displayOver,valueOver,value);\r
emit UpdateFusion(displayFus,valueFus);\r
}\r
-#endif\r
}\r
//----------------------------------------------------------------------------\r
\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
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
+ z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]+0.5)\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
+#endif\r
+ {\r
+ double value = this->GetScalarComponentAsDouble(mSlicers[mSelectedSlicer]->GetInput(), x_index, y_index, z_index); //Value in selected Slicer (not 0): bug #2848\r
this->GetLandmarks()->AddLandmark(x,y,z,t,value);\r
emit LandmarkAdded();\r
}\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
#else\r
int extentImageReslice[6];\r
mSlicers[0]->GetRegisterExtent(extentImageReslice);\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
+ z_index <= extentImageReslice[5]+0.5)\r
+#endif\r
+ {\r
+ double value = this->GetScalarComponentAsDouble(mSlicers[mSelectedSlicer]->GetInput(), x_index, y_index, z_index); //Value in selected Slicer (not 0): bug #2848\r
this->GetLandmarks()->AddLandmark(x,y,z,t,value);\r
- emit LandmarkAdded();\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