X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=vv%2FvvSlicerManager.cxx;h=fab1e8d8654bc145b392cce550641c85f92f2d60;hb=HEAD;hp=b175c46ccc642665487641e20c102b2e8c8e5d37;hpb=c7f88ac1c53bedf4c01562761bf1bd3c91773181;p=clitk.git diff --git a/vv/vvSlicerManager.cxx b/vv/vvSlicerManager.cxx index b175c46..fab1e8d 100644 --- a/vv/vvSlicerManager.cxx +++ b/vv/vvSlicerManager.cxx @@ -25,6 +25,9 @@ #include "vvMesh.h" #include "vvBlendImageActor.h" +#include +#include +#include #include #include #include @@ -40,10 +43,13 @@ #include #include - +#include //---------------------------------------------------------------------------- vvSlicerManager::vvSlicerManager(int numberOfSlicers) -{ +{ + + connect(this, SIGNAL(callAddLandmark(float,float,float,float)), this, SLOT(AddLandmark(float,float,float,float))); + mFileName = ""; mId = ""; mVFName = ""; @@ -63,23 +69,34 @@ vvSlicerManager::vvSlicerManager(int numberOfSlicers) mFusionLevel = 1000; mFusionShowLegend = true; + mFusionSequenceInvolvementCode = -1; + mFusionSequenceIndexLinkedManager = -1; + mFusionSequenceFrameIndex = -1; + mFusionSequenceNbFrames = 0; + mFusionSequenceSpatialSyncFlag = false; + mFusionSequenceTemporalSyncFlag = false; + mLandmarks = NULL; mLinkedId.resize(0); - for ( int i = 0; i < numberOfSlicers; i++) + for ( int i = 0; i < numberOfSlicers; i++) { mSlicers.push_back(vtkSmartPointer::New()); + mSlicers[i]->SetSlicerNumber(i); + } mSelectedSlicer = -1; - mPreviousSlice.resize(numberOfSlicers); - mPreviousTSlice.resize(numberOfSlicers); + mPreviousSlice.resize(numberOfSlicers, 0); + mPreviousTSlice.resize(numberOfSlicers, 0); mSlicingPreset = WORLD_SLICING; + + } //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- vvSlicerManager::~vvSlicerManager() -{ +{ if (mLandmarks) delete mLandmarks; } @@ -88,7 +105,7 @@ vvSlicerManager::~vvSlicerManager() //------------------------------------------------------------------------------ void vvSlicerManager::SetFilename(std::string filename, int number) -{ +{ mFileName = filename; mFileName = vtksys::SystemTools::GetFilenameName(mFileName); mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName)); @@ -110,7 +127,7 @@ void vvSlicerManager::SetFilename(std::string filename, int number) //---------------------------------------------------------------------------- void vvSlicerManager::AddContour(vvMesh::Pointer contour,bool propagate) -{ +{ for ( unsigned int i = 0; i < mSlicers.size(); i++) { mSlicers[i]->AddContour(contour,propagate); } @@ -120,7 +137,7 @@ void vvSlicerManager::AddContour(vvMesh::Pointer contour,bool propagate) //---------------------------------------------------------------------------- void vvSlicerManager::ToggleContourSuperposition() -{ +{ for ( unsigned int i = 0; i < mSlicers.size(); i++) mSlicers[i]->ToggleContourSuperposition(); } @@ -128,7 +145,7 @@ void vvSlicerManager::ToggleContourSuperposition() //---------------------------------------------------------------------------- std::string vvSlicerManager::GetListOfAbsoluteFilePathInOneString(const std::string &actorType) -{ +{ vvImageReader *reader = NULL; if(actorType=="image") @@ -139,6 +156,8 @@ std::string vvSlicerManager::GetListOfAbsoluteFilePathInOneString(const std::str reader = mFusionReader; else if(actorType=="vector") reader = mVectorReader; + else if(actorType=="fusionSequence") + reader = mFusionSequenceReader; if(!reader) return ""; @@ -157,7 +176,7 @@ std::string vvSlicerManager::GetListOfAbsoluteFilePathInOneString(const std::str //---------------------------------------------------------------------------- bool vvSlicerManager::SetImage(std::string filename, vvImageReader::LoadedImageType type, int n, unsigned int slice) -{ +{ mType = type; if (mReader.IsNull()) mReader = vvImageReader::New(); @@ -192,7 +211,7 @@ bool vvSlicerManager::SetImage(std::string filename, vvImageReader::LoadedImageT //---------------------------------------------------------------------------- void vvSlicerManager::SetImage(vvImage::Pointer image) -{ +{ mImage=image; for (unsigned int i = 0; i < mSlicers.size(); i++) { mSlicers[i]->SetImage(image); @@ -202,8 +221,8 @@ void vvSlicerManager::SetImage(vvImage::Pointer image) //---------------------------------------------------------------------------- -bool vvSlicerManager::SetImages(std::vector filenames, vvImageReader::LoadedImageType type, int n) -{ +bool vvSlicerManager::SetImages(std::vector filenames, vvImageReader::LoadedImageType type, int n, bool patientCoordinateSystem) +{ mType = type; std::string fileWithoutExtension = vtksys::SystemTools::GetFilenameWithoutExtension(filenames[0]); if (type == vvImageReader::DICOM) @@ -218,6 +237,8 @@ bool vvSlicerManager::SetImages(std::vector filenames, vvImageReade if (mReader.IsNull()) mReader = vvImageReader::New(); mReader->SetInputFilenames(filenames); + if (type == vvImageReader::DICOM) + mReader->SetPatientCoordinateSystem(patientCoordinateSystem); mReader->Update(type); mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName)); @@ -243,7 +264,7 @@ bool vvSlicerManager::SetImages(std::vector filenames, vvImageReade //---------------------------------------------------------------------------- bool vvSlicerManager::SetOverlay(std::vector filenames,int dim, std::string component, vvImageReader::LoadedImageType type) -{ +{ mOverlayName = filenames[0]; mOverlayComponent = component; if (dim > mImage->GetNumberOfDimensions()) { @@ -268,20 +289,18 @@ bool vvSlicerManager::SetOverlay(std::vector filenames,int dim, std //---------------------------------------------------------------------------- -bool vvSlicerManager::SetFusion(std::string filename,int dim, std::string component) -{ - mFusionName = filename; +bool vvSlicerManager::SetFusion(std::vector filenames,int dim, std::string component, vvImageReader::LoadedImageType type) +{ + mFusionName = filenames[0]; mFusionComponent = component; if (dim > mImage->GetNumberOfDimensions()) { - mLastError = " Overlay dimension cannot be greater then reference image!"; + mLastError = " Fusion dimension cannot be greater than reference image!"; return false; } if (mFusionReader.IsNull()) mFusionReader = vvImageReader::New(); - std::vector filenames; - filenames.push_back(filename); mFusionReader->SetInputFilenames(filenames); - mFusionReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType); + mFusionReader->Update(type); if (mFusionReader->GetLastError().size() == 0) { for ( unsigned int i = 0; i < mSlicers.size(); i++) { mSlicers[i]->SetFusion(mFusionReader->GetOutput()); @@ -298,10 +317,59 @@ bool vvSlicerManager::SetFusion(std::string filename,int dim, std::string compon } //---------------------------------------------------------------------------- +//---------------------------------------------------------------------------- +//this function is called by vvMainWindow::AddFusionSequence for the primary sequence (CT), while the given files constitute the secondary sequence. +bool vvSlicerManager::SetFusionSequence(std::vector filenames, int dim, std::string component, vvImageReader::LoadedImageType type) +{ + mFusionSequenceInvolvementCode = 0; + + mFusionName = filenames[0]; + mFusionComponent = component; + + if (dim > mImage->GetNumberOfDimensions()) { + mLastError = " Fusion Sequence dimension cannot be greater than reference image!"; + return false; + } + + if (mFusionSequenceReader.IsNull()) + mFusionSequenceReader = vvImageReader::New(); + + mFusionSequenceReader->SetInputFilenames(filenames); + mFusionSequenceReader->Update(type); + + + if (mFusionSequenceReader->GetLastError().size() == 0) { + for ( unsigned int i = 0; i < mSlicers.size(); i++) { + mSlicers[i]->SetFusion(mFusionSequenceReader->GetOutput(), mFusionSequenceInvolvementCode); + } + } else { + mLastError = mFusionSequenceReader->GetLastError(); + return false; + } + double *fusRange = mFusionSequenceReader->GetOutput()->GetVTKImages()[0]->GetScalarRange(); + mFusionLevel = (fusRange[0]+fusRange[1])/2; + mFusionWindow = fusRange[1]-fusRange[0]; + + //store the initial transform matrices of each frame, and reset them to identity + mFusionSequenceListInitialTransformMatrices.clear(); + for (unsigned i=0 ; iGetOutput()->GetTransform().size() ; i++) { + AddFusionSequenceInitialTransformMatrices( mFusionSequenceReader->GetOutput()->GetTransform()[i]->GetMatrix() ); + mFusionSequenceReader->GetOutput()->GetTransform()[i]->Identity(); + mFusionSequenceReader->GetOutput()->GetTransform()[i]->Update(); + } + + //adjust the time slider in the overlay panel + mFusionSequenceNbFrames = mFusionSequenceReader->GetOutput()->GetTransform().size(); + mFusionSequenceFrameIndex = std::max( 0, std::min(mFusionSequenceFrameIndex, mFusionSequenceNbFrames)); + + return true; +} +//---------------------------------------------------------------------------- + //---------------------------------------------------------------------------- bool vvSlicerManager::SetVF(std::string filename) -{ +{ if (mVectorReader.IsNull()) mVectorReader = vvImageReader::New(); mVectorReader->SetInputFilename(filename); @@ -321,7 +389,7 @@ bool vvSlicerManager::SetVF(std::string filename) //---------------------------------------------------------------------------- bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename) -{ +{ if (vf->GetNumberOfDimensions() > mImage->GetNumberOfDimensions()) { mLastError = "Sorry, vector field dimension cannot be greater then reference image."; return false; @@ -348,7 +416,7 @@ bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename) //---------------------------------------------------------------------------- vvSlicer* vvSlicerManager::GetSlicer(int i) -{ +{ return mSlicers[i]; } //---------------------------------------------------------------------------- @@ -356,16 +424,17 @@ vvSlicer* vvSlicerManager::GetSlicer(int i) //---------------------------------------------------------------------------- void vvSlicerManager::UpdateSlicer(int num, bool state) -{ - if (mSlicers[num]->GetImage()) +{ + if (mSlicers[num]->GetImage()) { mSlicers[num]->SetDisplayMode(state); + } } //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW) -{ +{ mSlicers[i]->SetRenderWindow(i,RW); } //---------------------------------------------------------------------------- @@ -373,7 +442,7 @@ void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW) //---------------------------------------------------------------------------- void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* style) -{ +{ vvSlicerManagerCommand *smc = vvSlicerManagerCommand::New(); smc->SM = this; smc->SetSlicerNumber(i); @@ -412,7 +481,7 @@ void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* sty //---------------------------------------------------------------------------- void vvSlicerManager::LeftButtonReleaseEvent(int slicer) -{ +{ emit LeftButtonReleaseSignal(slicer); } //---------------------------------------------------------------------------- @@ -420,7 +489,7 @@ void vvSlicerManager::LeftButtonReleaseEvent(int slicer) //---------------------------------------------------------------------------- void vvSlicerManager::EmitMousePositionUpdated(int slicer) -{ +{ emit MousePositionUpdatedSignal(slicer); } //---------------------------------------------------------------------------- @@ -428,7 +497,7 @@ void vvSlicerManager::EmitMousePositionUpdated(int slicer) //---------------------------------------------------------------------------- void vvSlicerManager::EmitKeyPressed(std::string KeyPress) -{ +{ emit KeyPressedSignal(KeyPress); } //---------------------------------------------------------------------------- @@ -436,7 +505,7 @@ void vvSlicerManager::EmitKeyPressed(std::string KeyPress) //---------------------------------------------------------------------------- void vvSlicerManager::SetSliceOrientation(int slicer, int orientation) -{ +{ mSlicers[slicer]->SetSliceOrientation(orientation); emit UpdateOrientation(slicer, orientation); } @@ -444,14 +513,22 @@ void vvSlicerManager::SetSliceOrientation(int slicer, int orientation) //---------------------------------------------------------------------------- int vvSlicerManager::GetTSlice() -{ +{ return mSlicers[0]->GetTSlice(); } //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- -void vvSlicerManager::SetTSlice(int slice) -{ +void vvSlicerManager::SetTSlice(int slice, bool updateLinkedImages) +{ + if (!updateLinkedImages) { //for fusionSequence, TMax / MaxCurrentTSlice are irrelevant. + for ( unsigned int i = 0; i < mSlicers.size(); i++) { + mSlicers[i]->SetTSlice(slice, updateLinkedImages); + UpdateTSlice(i); + } + return; + } + if (slice < 0) slice = 0; else if (slice > mSlicers[0]->GetTMax()) @@ -460,7 +537,7 @@ void vvSlicerManager::SetTSlice(int slice) mLandmarks->SetTime(slice); for ( unsigned int i = 0; i < mSlicers.size(); i++) { if (slice != mSlicers[i]->GetMaxCurrentTSlice()) { - mSlicers[i]->SetTSlice(slice); + mSlicers[i]->SetTSlice(slice, updateLinkedImages); UpdateTSlice(i); } } @@ -468,37 +545,47 @@ void vvSlicerManager::SetTSlice(int slice) //---------------------------------------------------------------------------- +//---------------------------------------------------------------------------- +void vvSlicerManager::SetFusionSequenceTSlice(int slice) +{ + for ( unsigned int i = 0; i < mSlicers.size(); i++) { + mSlicers[i]->SetFusionSequenceTSlice(slice); + UpdateTSlice(i); + } +} +//---------------------------------------------------------------------------- + + //---------------------------------------------------------------------------- void vvSlicerManager::SetNextTSlice(int originating_slicer) -{ +{ int t = mSlicers[0]->GetMaxCurrentTSlice(); t++; if (t > mSlicers[0]->GetTMax()) t = 0; - //std::cout << "vvSlicerManager::SetNextTSlice" << std::endl; - emit UpdateTSlice(originating_slicer,t); + emit UpdateTSlice(originating_slicer,t, mFusionSequenceInvolvementCode); } //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- void vvSlicerManager::SetPreviousTSlice(int originating_slicer) -{ +{ int t = mSlicers[0]->GetMaxCurrentTSlice(); t--; if (t < 0) t = mSlicers[0]->GetTMax(); - //std::cout << "vvSlicerManager::SetPreviousTSlice" << std::endl; - emit UpdateTSlice(originating_slicer,t); + emit UpdateTSlice(originating_slicer,t, mFusionSequenceInvolvementCode); } //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- void vvSlicerManager::ToggleInterpolation() -{ +{ bool interpolate=!(mSlicers[0]->GetImageActor()->GetInterpolate()); for ( unsigned int i = 0; i < mSlicers.size(); i++) { + mSlicers[i]->SetInterpolationImageReslice(interpolate); mSlicers[i]->GetImageActor()->SetInterpolate(interpolate); if (mSlicers[i]->GetOverlayActor()) mSlicers[i]->GetOverlayActor()->SetInterpolate(interpolate); @@ -511,7 +598,7 @@ void vvSlicerManager::ToggleInterpolation() //---------------------------------------------------------------------------- void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer) -{ +{ if (tslice < 0) tslice = 0; else if (tslice > mSlicers[slicer]->GetTMax()) @@ -537,7 +624,7 @@ void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer) //---------------------------------------------------------------------------- void vvSlicerManager::SetColorWindow(double s) -{ +{ for ( unsigned int i = 0; i < mSlicers.size(); i++) { mSlicers[i]->SetColorWindow(s); } @@ -546,7 +633,7 @@ void vvSlicerManager::SetColorWindow(double s) //---------------------------------------------------------------------------- void vvSlicerManager::SetColorLevel(double s) -{ +{ for ( unsigned int i = 0; i < mSlicers.size(); i++) { mSlicers[i]->SetColorLevel(s); } @@ -555,7 +642,7 @@ void vvSlicerManager::SetColorLevel(double s) //---------------------------------------------------------------------------- void vvSlicerManager::SetOverlayColorWindow(double s) -{ +{ for ( unsigned int i = 0; i < mSlicers.size(); i++) { mSlicers[i]->SetOverlayColorWindow(s); } @@ -564,7 +651,7 @@ void vvSlicerManager::SetOverlayColorWindow(double s) //---------------------------------------------------------------------------- void vvSlicerManager::SetOverlayColorLevel(double s) -{ +{ for ( unsigned int i = 0; i < mSlicers.size(); i++) { mSlicers[i]->SetOverlayColorLevel(s); } @@ -573,7 +660,7 @@ void vvSlicerManager::SetOverlayColorLevel(double s) //---------------------------------------------------------------------------- void vvSlicerManager::SetLinkOverlayWindowLevel(bool b) -{ +{ for ( unsigned int i = 0; i < mSlicers.size(); i++) { mSlicers[i]->SetLinkOverlayWindowLevel(b); } @@ -582,7 +669,7 @@ void vvSlicerManager::SetLinkOverlayWindowLevel(bool b) //---------------------------------------------------------------------------- void vvSlicerManager::SetCursorAndCornerAnnotationVisibility(int s) -{ +{ for ( unsigned int i = 0; i < mSlicers.size(); i++) { mSlicers[i]->SetCursorVisibility(s); mSlicers[i]->SetCornerAnnotationVisibility(s); @@ -592,7 +679,7 @@ void vvSlicerManager::SetCursorAndCornerAnnotationVisibility(int s) //---------------------------------------------------------------------------- void vvSlicerManager::SetOpacity(int i, double factor) -{ +{ mSlicers[i]->SetOpacity(1/factor); } //---------------------------------------------------------------------------- @@ -600,7 +687,7 @@ void vvSlicerManager::SetOpacity(int i, double factor) //---------------------------------------------------------------------------- void vvSlicerManager::UpdateViews(int current,int slicer) -{ +{ double p[3], pt[3]; p[0] = mSlicers[slicer]->GetCurrentPosition()[0]; p[1] = mSlicers[slicer]->GetCurrentPosition()[1]; @@ -613,15 +700,26 @@ void vvSlicerManager::UpdateViews(int current,int slicer) /mSlicers[slicer]->GetInput()->GetSpacing()[1]; double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2]) /mSlicers[slicer]->GetInput()->GetSpacing()[2]; - +#if VTK_MAJOR_VERSION <= 5 if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 && x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 && y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 && y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 && z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 && - z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) { + z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) +#else +int extentImageReslice[6]; +mSlicers[slicer]->GetRegisterExtent(extentImageReslice); + if (x >= extentImageReslice[0]-0.5 && + x <= extentImageReslice[1]+0.5 && + y >= extentImageReslice[2]-0.5 && + y <= extentImageReslice[3]+0.5 && + z >= extentImageReslice[4]-0.5 && + z <= extentImageReslice[5]+0.5) +#endif + { mSlicers[slicer]->UpdateCursorPosition(); - mSlicers[slicer]->SetCursorColor(10,212,255); + mSlicers[slicer]->SetCursorColor(1,0,0); mSelectedSlicer = slicer; switch (mSlicers[slicer]->GetSliceOrientation()) { @@ -652,9 +750,9 @@ void vvSlicerManager::UpdateViews(int current,int slicer) if (current) { //do not display corner annotation if image is the one picked mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX, -VTK_DOUBLE_MAX, mSlicers[slicer]->GetMaxCurrentTSlice()); - mSlicers[i]->SetCursorColor(255,10,212); + mSlicers[i]->SetCursorColor(0,0.96,0.17); } else { - mSlicers[i]->SetCursorColor(150,10,282); + mSlicers[i]->SetCursorColor(0.41,0.96,1); } switch (mSlicers[i]->GetSliceOrientation()) { case vtkImageViewer2::SLICE_ORIENTATION_XY: @@ -686,7 +784,7 @@ void vvSlicerManager::UpdateViews(int current,int slicer) //---------------------------------------------------------------------------- void vvSlicerManager::UpdateLinked(int slicer) -{ +{ double p[3], pt[3]; p[0] = mSlicers[slicer]->GetCurrentPosition()[0]; p[1] = mSlicers[slicer]->GetCurrentPosition()[1]; @@ -695,15 +793,32 @@ void vvSlicerManager::UpdateLinked(int slicer) double x = (pt[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0]) / mSlicers[slicer]->GetInput()->GetSpacing()[0]; double y = (pt[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1]) / mSlicers[slicer]->GetInput()->GetSpacing()[1]; double z = (pt[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2]) / mSlicers[slicer]->GetInput()->GetSpacing()[2]; - +#if VTK_MAJOR_VERSION <= 5 if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0]-0.5 && x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1]+0.5 && y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2]-0.5 && y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3]+0.5 && z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4]-0.5 && - z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) { + z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]+0.5) +#else +int extentImageReslice[6]; +mSlicers[slicer]->GetRegisterExtent(extentImageReslice); + if (x >= extentImageReslice[0]-0.5 && + x <= extentImageReslice[1]+0.5 && + y >= extentImageReslice[2]-0.5 && + y <= extentImageReslice[3]+0.5 && + z >= extentImageReslice[4]-0.5 && + z <= extentImageReslice[5]+0.5) +#endif + { for (std::list::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) { - emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice()); + if (this->IsInvolvedInFusionSequence()) { + //this SlicerManager is involved in fusionSequence => do not synchronize the times + emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], -1); + } + else { + emit UpdateLinkManager(*i, slicer, p[0], p[1], p[2], mSlicers[slicer]->GetMaxCurrentTSlice()); + } } } } @@ -711,7 +826,7 @@ void vvSlicerManager::UpdateLinked(int slicer) //---------------------------------------------------------------------------- void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate) -{ +{ vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera(); double refPosition[3]; @@ -754,7 +869,7 @@ void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagat //---------------------------------------------------------------------------- double vvSlicerManager::GetColorWindow() const -{ +{ if (mSlicers.size()) return mSlicers[0]->GetColorWindow(); return -1; @@ -764,7 +879,7 @@ double vvSlicerManager::GetColorWindow() const //---------------------------------------------------------------------------- double vvSlicerManager::GetColorLevel() const -{ +{ if (mSlicers.size()) return mSlicers[0]->GetColorLevel(); return -1; @@ -773,7 +888,7 @@ double vvSlicerManager::GetColorLevel() const //---------------------------------------------------------------------------- double vvSlicerManager::GetOverlayColorWindow() const -{ +{ if (mSlicers.size()) return mSlicers[0]->GetOverlayColorWindow(); return -1; @@ -782,7 +897,7 @@ double vvSlicerManager::GetOverlayColorWindow() const //---------------------------------------------------------------------------- double vvSlicerManager::GetOverlayColorLevel() const -{ +{ if (mSlicers.size()) return mSlicers[0]->GetOverlayColorLevel(); return -1; @@ -791,7 +906,7 @@ double vvSlicerManager::GetOverlayColorLevel() const //---------------------------------------------------------------------------- bool vvSlicerManager::GetLinkOverlayWindowLevel() const -{ +{ if (mSlicers.size()) return mSlicers[0]->GetLinkOverlayWindowLevel(); return -1; @@ -800,7 +915,7 @@ bool vvSlicerManager::GetLinkOverlayWindowLevel() const //------------------------------------------------------------------------------ void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType) -{ +{ if(actorType == "image") for(unsigned int i=0; iGetImage()->GetTransform().size(); i++) this->GetImage()->GetTransform()[i]->Identity(); @@ -810,6 +925,9 @@ void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType) else if(actorType == "fusion") for(unsigned int i=0; iGetImage()->GetTransform().size(); i++) this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity(); + else if(actorType == "fusionSequence") //TODO: Check what should really be done here + for(unsigned int i=0; iGetImage()->GetTransform().size(); i++) + this->GetSlicer(0)->GetFusion()->GetTransform()[i]->Identity(); else if(actorType == "vf") for(unsigned int i=0; iGetImage()->GetTransform().size(); i++) this->GetVF()->GetTransform()[i]->Identity(); @@ -826,7 +944,7 @@ void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType) //---------------------------------------------------------------------------- void vvSlicerManager::Render() -{ +{ for ( unsigned int i = 0; i < mSlicers.size(); i++) { mSlicers[i]->Render(); } @@ -836,7 +954,7 @@ void vvSlicerManager::Render() //---------------------------------------------------------------------------- void vvSlicerManager::GenerateDefaultLookupTable() -{ +{ SetPreset(mPreset); SetColorMap(mColorMap); } @@ -845,19 +963,24 @@ void vvSlicerManager::GenerateDefaultLookupTable() //---------------------------------------------------------------------------- void vvSlicerManager::Reload() -{ +{ mReader->Update(mType); mImage=mReader->GetOutput(); for ( unsigned int i = 0; i < mSlicers.size(); i++) { mSlicers[i]->SetImage(mImage); } + + //if this image is the primary sequence of a fusion sequence, then the main transform matrix should be updated. + if (this->IsMainSequenceOfFusionSequence()) { + SetFusionSequenceMainTransformMatrix( mImage->GetTransform()[0]->GetMatrix() ); + } } //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- void vvSlicerManager::ReloadFusion() -{ +{ mFusionReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),mType); for ( unsigned int i = 0; i < mSlicers.size(); i++) { @@ -867,10 +990,47 @@ void vvSlicerManager::ReloadFusion() } //---------------------------------------------------------------------------- +//---------------------------------------------------------------------------- +//the secondary sequence is being reloaded. +void vvSlicerManager::ReloadFusionSequence() +{ + // this is to keep the slice thickness, which needs to be artificially increased for visualization + double sp_x, sp_y, sp_z; + this->GetImage()->GetVTKImages()[0]->GetSpacing(sp_x, sp_y, sp_z); + + mFusionSequenceReader->Update(mImage->GetNumberOfDimensions(),mFusionComponent.c_str(),vvImageReader::MERGEDWITHTIME); + + for ( unsigned int i = 0; i < mSlicers.size(); i++) { + mSlicers[i]->SetFusion(mFusionSequenceReader->GetOutput(), 1); + mSlicers[i]->Render(); + } + + //Update the slider + mFusionSequenceNbFrames = mFusionSequenceReader->GetOutput()->GetTransform().size(); + if (mFusionSequenceFrameIndex>=mFusionSequenceNbFrames) { + mFusionSequenceFrameIndex=0; + } + + //Update the list of initial transforms + mFusionSequenceListInitialTransformMatrices.clear(); + for (unsigned i=0 ; iAddFusionSequenceInitialTransformMatrices( mFusionSequenceReader->GetOutput()->GetTransform()[i]->GetMatrix() ); + } + + // also update the slice thickness + for (unsigned i=0 ; iGetImage()->GetTransform().size() ; i++) { + sp_x = this->GetImage()->GetVTKImages()[i]->GetSpacing()[0]; + sp_y = this->GetImage()->GetVTKImages()[i]->GetSpacing()[1]; + this->GetImage()->GetVTKImages()[i]->SetSpacing( sp_x, sp_y, sp_z); + } + +} +//---------------------------------------------------------------------------- + //---------------------------------------------------------------------------- void vvSlicerManager::ReloadOverlay() -{ +{ mOverlayReader->Update(mImage->GetNumberOfDimensions(),mOverlayComponent.c_str(),mType); for ( unsigned int i = 0; i < mSlicers.size(); i++) { mSlicers[i]->SetOverlay(mOverlayReader->GetOutput()); @@ -882,7 +1042,7 @@ void vvSlicerManager::ReloadOverlay() //---------------------------------------------------------------------------- void vvSlicerManager::ReloadVF() -{ +{ mVectorReader->Update(vvImageReader::VECTORFIELD); //deletes the old images through the VF::Init() function mVF=mVectorReader->GetOutput(); for ( unsigned int i = 0; i < mSlicers.size(); i++) { @@ -895,13 +1055,17 @@ void vvSlicerManager::ReloadVF() //---------------------------------------------------------------------------- void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index) -{ +{ if (actor_type =="overlay") mOverlayReader = NULL; if (actor_type =="fusion") mFusionReader = NULL; + if (actor_type =="fusionSequence") { + mFusionSequenceReader = NULL; + } + for (unsigned int i = 0; i < mSlicers.size(); i++) mSlicers[i]->RemoveActor(actor_type,overlay_index); @@ -915,7 +1079,7 @@ void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_ind //---------------------------------------------------------------------------- void vvSlicerManager::RemoveActors() -{ +{ ///This method leaks a few objects. See RemoveActor for what a ///correct implementation would look like //DS -> probably due to the reader (now released in the @@ -930,30 +1094,44 @@ void vvSlicerManager::RemoveActors() //---------------------------------------------------------------------------- void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer) -{ +{ // int view = mSlicers[slicer]->GetSliceOrientation(); // int slice = mSlicers[slicer]->GetSlice(); - double x = mSlicers[slicer]->GetCursorPosition()[0]; - double y = mSlicers[slicer]->GetCursorPosition()[1]; - double z = mSlicers[slicer]->GetCursorPosition()[2]; - double X = (x - mSlicers[slicer]->GetInput()->GetOrigin()[0])/ - mSlicers[slicer]->GetInput()->GetSpacing()[0]; - double Y = (y - mSlicers[slicer]->GetInput()->GetOrigin()[1])/ - mSlicers[slicer]->GetInput()->GetSpacing()[1]; - double Z = (z - mSlicers[slicer]->GetInput()->GetOrigin()[2])/ - mSlicers[slicer]->GetInput()->GetSpacing()[2]; + double x = mSlicers[slicer]->GetCurrentPosition()[0]; + double y = mSlicers[slicer]->GetCurrentPosition()[1]; + double z = mSlicers[slicer]->GetCurrentPosition()[2]; + double xyz[3], xyzTransform[3]; + xyz[0] = x; + xyz[1] = y; + xyz[2] = z; + mSlicers[slicer]->GetSlicingTransform()->GetInverse()->TransformPoint(xyz, xyzTransform); + double X = (xyzTransform[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])/mSlicers[slicer]->GetInput()->GetSpacing()[0]; + double Y = (xyzTransform[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])/mSlicers[slicer]->GetInput()->GetSpacing()[1]; + double Z = (xyzTransform[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])/mSlicers[slicer]->GetInput()->GetSpacing()[2]; double value = -VTK_DOUBLE_MAX; int displayVec = 0; double xVec=0, yVec=0, zVec=0, valueVec=0; int displayOver = 0; int displayFus = 0; double valueOver=0, valueFus=0; - if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] && - X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] && - Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] && - Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] && - Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] && - Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) { +#if VTK_MAJOR_VERSION <= 5 + if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] -0.5 && + X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] +0.5 && + Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] -0.5 && + Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] +0.5 && + Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] -0.5 && + Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5] +0.5) +#else +int extentImageReslice[6]; +mSlicers[slicer]->GetRegisterExtent(extentImageReslice); + if (X >= extentImageReslice[0] -0.5 && + X <= extentImageReslice[1] +0.5 && + Y >= extentImageReslice[2] -0.5 && + Y <= extentImageReslice[3] +0.5 && + Z >= extentImageReslice[4] -0.5 && + Z <= extentImageReslice[5] +0.5) +#endif + { value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z); if (mSlicers[slicer]->GetVFActor() ) { @@ -984,14 +1162,22 @@ void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer) double Zover = (z - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2]; valueOver = this->GetScalarComponentAsDouble(overlay, Xover, Yover, Zover); } - if (mSlicers[slicer]->GetFusionActor() ) { - displayFus = 1; - vtkImageData *fusion = dynamic_cast(mSlicers[slicer]->GetFusionMapper()->GetInput()); - double Xover = (x - fusion->GetOrigin()[0]) / fusion->GetSpacing()[0]; - double Yover = (y - fusion->GetOrigin()[1]) / fusion->GetSpacing()[1]; - double Zover = (z - fusion->GetOrigin()[2]) / fusion->GetSpacing()[2]; - valueFus = this->GetScalarComponentAsDouble(fusion, Xover, Yover, Zover); - } + + if ( mSlicers[slicer]->GetFusionActor() ) { + displayFus = 1; + vtkImageData *fusion = dynamic_cast(mSlicers[slicer]->GetFusionMapper()->GetInput()); + double Xover = (x - fusion->GetOrigin()[0]) / fusion->GetSpacing()[0]; + double Yover = (y - fusion->GetOrigin()[1]) / fusion->GetSpacing()[1]; + double Zover = (z - fusion->GetOrigin()[2]) / fusion->GetSpacing()[2]; + valueFus = this->GetScalarComponentAsDouble(fusion, Xover, Yover, Zover); + } + else if (this->IsInvolvedInFusionSequence()) { + //if the cursor moves over the 'independent' version of the secondary sequence + //do not update the panel, just keep it as it is. + displayFus = 1; + valueFus = std::numeric_limits::quiet_NaN(); + } + emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(), x,y,z,X,Y,Z,value); emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec); @@ -1004,7 +1190,7 @@ void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer) //---------------------------------------------------------------------------- void vvSlicerManager::Activated() -{ +{ emit currentImageChanged(mId); } //---------------------------------------------------------------------------- @@ -1012,7 +1198,7 @@ void vvSlicerManager::Activated() //---------------------------------------------------------------------------- void vvSlicerManager::Picked() -{ +{ emit currentPickedImageChanged(mId); } //---------------------------------------------------------------------------- @@ -1020,7 +1206,7 @@ void vvSlicerManager::Picked() //---------------------------------------------------------------------------- void vvSlicerManager::UpdateWindowLevel() -{ +{ emit WindowLevelChanged(); } //---------------------------------------------------------------------------- @@ -1028,12 +1214,11 @@ void vvSlicerManager::UpdateWindowLevel() //---------------------------------------------------------------------------- void vvSlicerManager::UpdateSlice(int slicer) -{ +{ if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) { //DD("============= NOTHING"); return; } - //std::cout << "vvSlicerManager::UpdateSlice " << slicer << " " << mSlicers[slicer]->GetSlice() << std::endl; emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice()); mSlicers[slicer]->Render(); // DS <-- I add this, this could/must be the only Render ... mPreviousSlice[slicer] = mSlicers[slicer]->GetSlice(); @@ -1043,9 +1228,12 @@ void vvSlicerManager::UpdateSlice(int slicer) //---------------------------------------------------------------------------- void vvSlicerManager::UpdateTSlice(int slicer) -{ +{ int slice = mSlicers[slicer]->GetSlice(); + int tslice = mSlicers[slicer]->GetMaxCurrentTSlice(); + //if (this->IsInvolvedInFusionSequence()) tslice = mSlicers[slicer]->GetTSlice(); //actually, this is handled by the Slicer + if (mPreviousSlice[slicer] == slice) { if (mPreviousTSlice[slicer] == tslice) { // DD("************** NOTHING ***********"); @@ -1054,15 +1242,15 @@ void vvSlicerManager::UpdateTSlice(int slicer) } mPreviousSlice[slicer] = slice; mPreviousTSlice[slicer] = tslice; - //std::cout << "vvSlicerManager::UpdateTSlice " << slicer << " " << tslice << std::endl; - emit UpdateTSlice(slicer, tslice); + + emit UpdateTSlice(slicer, tslice, mFusionSequenceInvolvementCode); } //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- void vvSlicerManager::UpdateSliceRange(int slicer) -{ +{ emit UpdateSliceRange(slicer, mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1], 0,mSlicers[slicer]->GetTMax()); @@ -1071,7 +1259,7 @@ void vvSlicerManager::UpdateSliceRange(int slicer) //---------------------------------------------------------------------------- void vvSlicerManager::SetSlicingPreset(SlicingPresetType preset) -{ +{ if(mSlicingPreset==preset) return; @@ -1093,8 +1281,15 @@ void vvSlicerManager::SetSlicingPreset(SlicingPresetType preset) return; } s->ForceUpdateDisplayExtent(); +#if VTK_MAJOR_VERSION <= 5 s->SetSlice((s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2+1] +s->GetInput()->GetWholeExtent()[s->GetSliceOrientation()*2])/2.0); +#else + int extentImageReslice[6]; + s->GetRegisterExtent(extentImageReslice); + s->SetSlice((extentImageReslice[s->GetSliceOrientation()*2+1] + +extentImageReslice[s->GetSliceOrientation()*2])/2.0); +#endif s->ResetCamera(); s->Render(); } @@ -1107,42 +1302,47 @@ void vvSlicerManager::SetSlicingPreset(SlicingPresetType preset) //---------------------------------------------------------------------------- void vvSlicerManager::SetPreset(int preset) -{ +{ + //vtkLookupTable* LUT = static_cast(mSlicers[0]->GetWindowLevel()->GetLookupTable()); double window = mSlicers[0]->GetColorWindow(); double level = mSlicers[0]->GetColorLevel(); std::string component_type=mImage->GetScalarTypeAsITKString(); switch (preset) { - case 0: + case WL_AUTO: double range[2]; mImage->GetScalarRange(range); window = range[1] - range[0]; level = (range[1] + range[0])* 0.5; break; - case 1: + case WL_HOUNSFIELD: window = 2000; level = 0; break; - case 2: + case WL_SOFTTISSUE: window = 400; level = 20; break; - case 3: // lungs (same as FOCAL) + case WL_LUNGS: // lungs (same as FOCAL) window = 1700; level = -300; break; - case 4: + case WL_BONES: window = 1000; level = 500; break; - case 5: + case WL_HEAD: + window = 200; + level = 70; + break; + case WL_BINARY: window = 1; level = 0.5; break; - case 6: + case WL_USER: break; - case 7: + case WL_VENTILATION: window=1.; level=0.; break; @@ -1161,7 +1361,7 @@ void vvSlicerManager::SetPreset(int preset) //---------------------------------------------------------------------------- void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlKey) -{ +{ double min, max; if(bCtrlKey && this->mSlicers[slicer]->GetFusion()) { int t = mSlicers[slicer]->GetFusionTSlice(); @@ -1192,9 +1392,8 @@ void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlK this->mSlicers[slicer]->GetConcatenatedTransform()); this->SetColorWindow(max-min); this->SetColorLevel(0.5*(min+max)); - this->SetPreset(6); + this->SetPreset(WL_USER); } - this->Render(); this->UpdateWindowLevel(); } //---------------------------------------------------------------------------- @@ -1202,8 +1401,9 @@ void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlK //---------------------------------------------------------------------------- void vvSlicerManager::SetColorMap(int colormap) -{ +{ double range[2]; + range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0]; range[1] = mSlicers[0]->GetInput()->GetScalarRange()[1]; @@ -1260,12 +1460,21 @@ void vvSlicerManager::SetColorMap(int colormap) LUT->Build(); } vtkWindowLevelLookupTable* fusLUT = NULL; + + //FUSION / FUSION SEQUENCE if (mSlicers[0]->GetFusion()) { // && mFusionColorMap >= 0) { fusLUT = vtkWindowLevelLookupTable::New(); double fusRange [2]; fusRange[0] = mFusionLevel - mFusionWindow/2; fusRange[1] = mFusionLevel + mFusionWindow/2; - double* frange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange(); + + //check whether it is actually a fusionSequence or a fusion, before invoking mFusionReader... + double* frange; + if (this->IsInvolvedInFusionSequence()) + frange = mFusionSequenceReader->GetOutput()->GetVTKImages()[0]->GetScalarRange(); + else + frange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange(); + fusLUT->SetTableRange(frange); fusLUT->SetValueRange(1,1); fusLUT->SetSaturationRange(1,1); @@ -1288,10 +1497,9 @@ void vvSlicerManager::SetColorMap(int colormap) fusLUT->SetValueRange(0,1); fusLUT->SetSaturationRange(0,0); } - + fusLUT->ForceBuild(); double v[4]; - // set color table transparency //double alpha_range=(double)mFusionThresOpacity/10; double range_end = fusRange[0] + (double)mFusionThresOpacity*(fusRange[1] - fusRange[0])/100; @@ -1307,7 +1515,7 @@ void vvSlicerManager::SetColorMap(int colormap) } } for ( unsigned int i = 0; i < mSlicers.size(); i++) { - + if (mSlicers[i]->GetOverlay()) { vtkLookupTable* supLUT = vtkLookupTable::New(); supLUT->SetTableRange(range[0],range[1]); @@ -1330,7 +1538,7 @@ void vvSlicerManager::SetColorMap(int colormap) } else { mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT); } - + if (mSlicers[i]->GetFusion()) { mSlicers[i]->ShowFusionLegend(mFusionShowLegend); mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT); @@ -1347,7 +1555,7 @@ void vvSlicerManager::SetColorMap(int colormap) //---------------------------------------------------------------------------- vvLandmarks* vvSlicerManager::GetLandmarks() -{ +{ if (mLandmarks == NULL) { mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1); for (unsigned int i = 0; i < mSlicers.size(); i++) @@ -1356,21 +1564,34 @@ vvLandmarks* vvSlicerManager::GetLandmarks() return mLandmarks; } //---------------------------------------------------------------------------- - +void vvSlicerManager::AddNewLandmark(float x,float y,float z,float t) +{ + emit callAddLandmark(x,y,z,t); +} //---------------------------------------------------------------------------- void vvSlicerManager::AddLandmark(float x,float y,float z,float t) -{ - double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0]; - double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1]; - double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2]; - if (x_index >= mSlicers[0]->GetInput()->GetWholeExtent()[0]-0.5 && - x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1]+0.5 && - y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2]-0.5 && - y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3]+0.5 && - z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4]-0.5 && - z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]+0.5) { - double value = this->GetScalarComponentAsDouble(mSlicers[0]->GetInput(), x_index, y_index, z_index); +{ + double x_index = (x - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[0])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[0]; + double y_index = (y - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[1])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[1]; + double z_index = (z - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[2])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[2]; +#if VTK_MAJOR_VERSION <= 5 + if (x_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[0]-0.5 && + x_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[1]+0.5 && + y_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[2]-0.5 && + y_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[3]+0.5 && + z_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[4]-0.5 && + z_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[5]+0.5) +#else + if (x_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[0]-0.5 && + x_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[1]+0.5 && + y_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[2]-0.5 && + y_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[3]+0.5 && + z_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[4]-0.5 && + z_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[5]+0.5) +#endif + { + double value = this->GetScalarComponentAsDouble(mSlicers[mSelectedSlicer]->GetImage()->GetVTKImages()[mSlicers[mSelectedSlicer]->GetTSlice()], x_index, y_index, z_index); //Value in selected Slicer (not 0): bug #2848 this->GetLandmarks()->AddLandmark(x,y,z,t,value); emit LandmarkAdded(); } @@ -1378,22 +1599,57 @@ void vvSlicerManager::AddLandmark(float x,float y,float z,float t) //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- -void vvSlicerManager::PrevImage(int slicer) +void vvSlicerManager::AddLandmarkProfile(float x,float y,float z,float t) +{ + double x_index = (x - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[0])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[0]; + double y_index = (y - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[1])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[1]; + double z_index = (z - mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetOrigin()[2])/mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetSpacing()[2]; +#if VTK_MAJOR_VERSION <= 5 + if (x_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[0]-0.5 && + x_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[1]+0.5 && + y_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[2]-0.5 && + y_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[3]+0.5 && + z_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[4]-0.5 && + z_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetWholeExtent()[5]+0.5) +#else + if (x_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[0]-0.5 && + x_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[1]+0.5 && + y_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[2]-0.5 && + y_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[3]+0.5 && + z_index >= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[4]-0.5 && + z_index <= mSlicers[0]->GetImage()->GetVTKImages()[mSlicers[0]->GetTSlice()]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[5]+0.5) +#endif + { + double value = this->GetScalarComponentAsDouble(mSlicers[mSelectedSlicer]->GetImage()->GetVTKImages()[mSlicers[mSelectedSlicer]->GetTSlice()], x_index, y_index, z_index); //Value in selected Slicer (not 0): bug #2848 + this->GetLandmarks()->AddLandmark(x,y,z,t,value); + } +} +//---------------------------------------------------------------------------- + +//---------------------------------------------------------------------------- +void vvSlicerManager::UpdateLandmark() { + this->GetLandmarks()->TransformUpdate(mSlicers[mSelectedSlicer]->GetConcatenatedTransform()->GetInverse()); +} +//---------------------------------------------------------------------------- + +//---------------------------------------------------------------------------- +void vvSlicerManager::PrevImage(int slicer) +{ emit ChangeImageWithIndexOffset(this, slicer, -1); } //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- void vvSlicerManager::NextImage(int slicer) -{ +{ emit ChangeImageWithIndexOffset(this, slicer, 1); } //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice) -{ +{ emit AVerticalSliderHasChanged(slicer, slice); } @@ -1401,7 +1657,7 @@ void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice) //---------------------------------------------------------------------------- double vvSlicerManager::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int component) -{ +{ int ix, iy, iz; return mSlicers[0]->GetScalarComponentAsDouble(image, X, Y, Z, ix, iy, iz, component); }