X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=vv%2FvvSlicer.cxx;h=7efaf2675c4caa351f090d1ce2de2a5d3e397972;hb=30133023f12212c84e7b4e9318f1055ec3176af1;hp=e070e5aac97d6136e84cae5dba86c92b2cbbcd3c;hpb=067cf5847bb412d0067bcd52d7844377a0a43635;p=clitk.git diff --git a/vv/vvSlicer.cxx b/vv/vvSlicer.cxx index e070e5a..7efaf26 100644 --- a/vv/vvSlicer.cxx +++ b/vv/vvSlicer.cxx @@ -75,8 +75,8 @@ #include #include #include -#include #if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10) +# include # include # include #endif @@ -90,12 +90,12 @@ static void copyExtent(int* in, int* to){ } //------------------------------------------------------------------------------ vvSlicer::vvSlicer() -{ //out << __func__ << endl; +{ mFusionSequenceCode = -1; this->UnInstallPipeline(); mImage = NULL; mReducedExtent = new int[6]; - mRegisterExtent = new int[6]; + mRegisterExtent = NULL; mCurrentTSlice = 0; mCurrentFusionTSlice = 0; mCurrentOverlayTSlice = 0; @@ -128,7 +128,7 @@ vvSlicer::vvSlicer() #if VTK_MAJOR_VERSION <= 5 pdm->SetInput(crossCursor->GetOutput()); #else - pdm->SetInputData(crossCursor->GetOutput()); + pdm->SetInputConnection(crossCursor->GetOutputPort(0)); #endif pdmA = vtkSmartPointer::New(); @@ -176,7 +176,7 @@ vvSlicer::vvSlicer() //------------------------------------------------------------------------------ vtkImageMapToWindowLevelColors* vvSlicer::GetOverlayMapper() -{ //out << __func__ << endl; +{ return mOverlayMapper.GetPointer(); } //------------------------------------------------------------------------------ @@ -184,7 +184,7 @@ vtkImageMapToWindowLevelColors* vvSlicer::GetOverlayMapper() //------------------------------------------------------------------------------ vvBlendImageActor* vvSlicer::GetOverlayActor() -{ //out << __func__ << endl; +{ return mOverlayActor.GetPointer(); } //------------------------------------------------------------------------------ @@ -192,7 +192,7 @@ vvBlendImageActor* vvSlicer::GetOverlayActor() //------------------------------------------------------------------------------ vtkImageMapToColors* vvSlicer::GetFusionMapper() -{ //out << __func__ << endl; +{ return mFusionMapper.GetPointer(); } //------------------------------------------------------------------------------ @@ -200,7 +200,7 @@ vtkImageMapToColors* vvSlicer::GetFusionMapper() //------------------------------------------------------------------------------ vtkImageActor* vvSlicer::GetFusionActor() -{ //out << __func__ << endl; +{ return mFusionActor.GetPointer(); } //------------------------------------------------------------------------------ @@ -208,7 +208,7 @@ vtkImageActor* vvSlicer::GetFusionActor() //------------------------------------------------------------------------------ vtkActor* vvSlicer::GetVFActor() -{ //out << __func__ << endl; +{ return mVFActor.GetPointer(); } //------------------------------------------------------------------------------ @@ -216,7 +216,7 @@ vtkActor* vvSlicer::GetVFActor() //------------------------------------------------------------------------------ vtkCornerAnnotation* vvSlicer::GetAnnotation() -{ //out << __func__ << endl; +{ return ca.GetPointer(); } //------------------------------------------------------------------------------ @@ -224,7 +224,7 @@ vtkCornerAnnotation* vvSlicer::GetAnnotation() //------------------------------------------------------------------------------ void vvSlicer::EnableReducedExtent(bool b) -{ //out << __func__ << endl; +{ mUseReducedExtent = b; } //------------------------------------------------------------------------------ @@ -232,7 +232,7 @@ void vvSlicer::EnableReducedExtent(bool b) //------------------------------------------------------------------------------ void vvSlicer::SetReducedExtent(int * ext) -{ //out << __func__ << endl; +{ copyExtent(ext, mReducedExtent); } //------------------------------------------------------------------------------ @@ -240,7 +240,7 @@ void vvSlicer::SetReducedExtent(int * ext) //------------------------------------------------------------------------------ void vvSlicer::AddContour(vvMesh::Pointer contour,bool propagate) -{ //out << __func__ << endl; +{ mSurfaceCutActors.push_back(new vvMeshActor()); if (propagate) @@ -257,7 +257,7 @@ void vvSlicer::AddContour(vvMesh::Pointer contour,bool propagate) //------------------------------------------------------------------------------ void vvSlicer::ToggleContourSuperposition() -{ //out << __func__ << endl; +{ for (std::vector::iterator i=mSurfaceCutActors.begin(); i!=mSurfaceCutActors.end(); i++) (*i)->ToggleSuperposition(); @@ -267,7 +267,7 @@ void vvSlicer::ToggleContourSuperposition() //------------------------------------------------------------------------------ void vvSlicer::SetCursorColor(int r,int g, int b) -{ //out << __func__ << endl; +{ pdmA->GetProperty()->SetColor(r,g,b); } //------------------------------------------------------------------------------ @@ -275,7 +275,7 @@ void vvSlicer::SetCursorColor(int r,int g, int b) //------------------------------------------------------------------------------ void vvSlicer::SetCursorVisibility(bool s) -{ //out << __func__ << endl; +{ pdmA->SetVisibility(s); } //------------------------------------------------------------------------------ @@ -283,7 +283,7 @@ void vvSlicer::SetCursorVisibility(bool s) //------------------------------------------------------------------------------ bool vvSlicer::GetCursorVisibility() -{ //out << __func__ << endl; +{ return pdmA->GetVisibility(); } //------------------------------------------------------------------------------ @@ -291,7 +291,7 @@ bool vvSlicer::GetCursorVisibility() //------------------------------------------------------------------------------ void vvSlicer::SetCornerAnnotationVisibility(bool s) -{ //out << __func__ << endl; +{ ca->SetVisibility(s); } //------------------------------------------------------------------------------ @@ -299,7 +299,7 @@ void vvSlicer::SetCornerAnnotationVisibility(bool s) //------------------------------------------------------------------------------ bool vvSlicer::GetCornerAnnotationVisibility() -{ //out << __func__ << endl; +{ return ca->GetVisibility(); } //------------------------------------------------------------------------------ @@ -307,25 +307,24 @@ bool vvSlicer::GetCornerAnnotationVisibility() //------------------------------------------------------------------------------ vvSlicer::~vvSlicer() -{ //out << __func__ << endl; +{ for (std::vector::iterator i=mSurfaceCutActors.begin(); i!=mSurfaceCutActors.end(); i++) delete (*i); delete [] mReducedExtent; - delete [] mRegisterExtent; } //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ double* vvSlicer::GetCurrentPosition() -{ //out << __func__ << endl; +{ return mCurrentBeforeSlicingTransform; } //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ void vvSlicer::SetCurrentPosition(double x, double y, double z, int t) -{ //out << __func__ << endl; +{ mCurrentBeforeSlicingTransform[0]=x; mCurrentBeforeSlicingTransform[1]=y; mCurrentBeforeSlicingTransform[2]=z; @@ -337,7 +336,7 @@ void vvSlicer::SetCurrentPosition(double x, double y, double z, int t) //------------------------------------------------------------------------------ void vvSlicer::SetImage(vvImage::Pointer image) -{ //out << __func__ << endl; +{ if (image->GetVTKImages().size()) { mImage = image; @@ -381,12 +380,11 @@ void vvSlicer::SetImage(vvImage::Pointer image) // Make sure that the required part image has been computed extent[SliceOrientation*2] = Slice; extent[SliceOrientation*2+1] = Slice; - #if VTK_MAJOR_VERSION <= 5 mImageReslice->GetOutput()->SetUpdateExtent(extent); mImageReslice->GetOutput()->Update(); #else - mImageReslice->SetUpdateExtent(extent); + //mImageReslice->SetUpdateExtent(extent); mImageReslice->Update(); #endif @@ -401,7 +399,7 @@ void vvSlicer::SetImage(vvImage::Pointer image) //------------------------------------------------------------------------------ void vvSlicer::SetOverlay(vvImage::Pointer overlay) -{ //out << __func__ << endl; +{ if (overlay->GetVTKImages().size()) { mOverlay = overlay; mOverlayVisibility = true; @@ -419,10 +417,10 @@ void vvSlicer::SetOverlay(vvImage::Pointer overlay) mOverlayReslice->SetResliceTransform(mConcatenatedOverlayTransform); #if VTK_MAJOR_VERSION <= 5 mOverlayReslice->SetInput(0, mOverlay->GetFirstVTKImageData()); + mImageReslice->UpdateInformation(); #else mOverlayReslice->SetInputData(0, mOverlay->GetFirstVTKImageData()); #endif - mImageReslice->UpdateInformation(); mOverlayReslice->Update(); if (!mOverlayMapper) @@ -430,7 +428,7 @@ void vvSlicer::SetOverlay(vvImage::Pointer overlay) #if VTK_MAJOR_VERSION <= 5 mOverlayMapper->SetInput(mOverlayReslice->GetOutput()); #else - mOverlayMapper->SetInputData(mOverlayReslice->GetOutput()); + mOverlayMapper->SetInputConnection(mOverlayReslice->GetOutputPort(0)); #endif if (!mOverlayActor) { @@ -467,7 +465,7 @@ void vvSlicer::SetOverlay(vvImage::Pointer overlay) //------------------------------------------------------------------------------ void vvSlicer::SetFusion(vvImage::Pointer fusion, int fusionSequenceCode) -{ //out << __func__ << endl; +{ mFusionSequenceCode = fusionSequenceCode; if (fusion->GetVTKImages().size()) { mFusion = fusion; @@ -486,6 +484,7 @@ void vvSlicer::SetFusion(vvImage::Pointer fusion, int fusionSequenceCode) mFusionReslice->SetResliceTransform(mConcatenatedFusionTransform); #if VTK_MAJOR_VERSION <= 5 mFusionReslice->SetInput(0, mFusion->GetFirstVTKImageData()); + mFusionReslice->UpdateInformation(); #else mFusionReslice->SetInputData(0, mFusion->GetFirstVTKImageData()); #endif @@ -503,7 +502,7 @@ void vvSlicer::SetFusion(vvImage::Pointer fusion, int fusionSequenceCode) #if VTK_MAJOR_VERSION <= 5 mFusionMapper->SetInput(mFusionReslice->GetOutput()); #else - mFusionMapper->SetInputData(mFusionReslice->GetOutput()); + mFusionMapper->SetInputConnection(mFusionReslice->GetOutputPort(0)); #endif if (!mFusionActor) { @@ -534,7 +533,7 @@ void vvSlicer::SetFusion(vvImage::Pointer fusion, int fusionSequenceCode) //------------------------------------------------------------------------------ bool vvSlicer::GetActorVisibility(const std::string& actor_type, int overlay_index) -{ //out << __func__ << endl; +{ bool vis = false; if (actor_type == "image") vis = mImageVisibility; @@ -552,7 +551,7 @@ bool vvSlicer::GetActorVisibility(const std::string& actor_type, int overlay_ind //------------------------------------------------------------------------------ void vvSlicer::SetActorVisibility(const std::string& actor_type, int overlay_index ,bool vis) -{ //out << __func__ << endl; +{ if (actor_type == "image") mImageVisibility = vis; else if (actor_type == "vector") @@ -569,7 +568,7 @@ void vvSlicer::SetActorVisibility(const std::string& actor_type, int overlay_ind //------------------------------------------------------------------------------ void vvSlicer::SetVF(vvImage::Pointer vf) -{ //out << __func__ << endl; +{ if (vf->GetVTKImages().size()) { mVF = vf; mVFVisibility = true; @@ -584,7 +583,7 @@ void vvSlicer::SetVF(vvImage::Pointer vf) mAAFilter->SetInput(mVOIFilter->GetOutput()); #else mVOIFilter->SetInputData(vf->GetFirstVTKImageData()); - mAAFilter->SetInputData(mVOIFilter->GetOutput()); + mAAFilter->SetInputConnection(mVOIFilter->GetOutputPort()); #endif ///This tells VTK to use the scalar (pixel) data of the image to draw the little arrows mAAFilter->Assign(vtkDataSetAttributes::SCALARS, vtkDataSetAttributes::VECTORS, vtkAssignAttribute::POINT_DATA); @@ -602,8 +601,8 @@ void vvSlicer::SetVF(vvImage::Pointer vf) mGlyphFilter->SetInput(mAAFilter->GetOutput()); mGlyphFilter->SetSource(mArrow->GetOutput()); #else - mGlyphFilter->SetInputData(mAAFilter->GetOutput()); - mGlyphFilter->SetSourceData(mArrow->GetOutput()); + mGlyphFilter->SetInputConnection(mAAFilter->GetOutputPort()); + mGlyphFilter->SetSourceConnection(mArrow->GetOutputPort()); #endif mGlyphFilter->ScalingOn(); mGlyphFilter->SetScaleModeToScaleByVector(); @@ -625,7 +624,7 @@ void vvSlicer::SetVF(vvImage::Pointer vf) #if VTK_MAJOR_VERSION <= 5 mVFMapper->SetInput(mGlyphFilter->GetOutput()); #else - mVFMapper->SetInputData(mGlyphFilter->GetOutput()); + mVFMapper->SetInputConnection(mGlyphFilter->GetOutputPort()); #endif mVFMapper->ImmediateModeRenderingOn(); mVFMapper->SetLookupTable(mVFColorLUT); @@ -647,7 +646,7 @@ void vvSlicer::SetVF(vvImage::Pointer vf) //------------------------------------------------------------------------------ void vvSlicer::SetLandmarks(vvLandmarks* landmarks) -{ //out << __func__ << endl; +{ mLandmarks = landmarks; if (landmarks) { @@ -672,15 +671,27 @@ void vvSlicer::SetLandmarks(vvLandmarks* landmarks) mLandClipper->SetClipFunction(mClipBox); mLandClipper->InsideOutOn(); #if VTK_MAJOR_VERSION <= 5 - mLandClipper->SetInput(mLandmarks->GetOutput()); + mLandmarkTransform = vtkSmartPointer::New(); + mLandmarkTransform->SetInput(mLandmarks->GetOutput()); + mConcatenatedTransform->Identity(); + mConcatenatedTransform->Concatenate(mImage->GetTransform()[0]); + mConcatenatedTransform->Concatenate(mSlicingTransform); + mLandmarkTransform->SetTransform(mConcatenatedTransform->GetInverse()); + mLandClipper->SetInput(mLandmarkTransform->GetOutput()); mLandGlyph->SetSource(mCross->GetOutput()); mLandGlyph->SetInput(mLandClipper->GetOutput()); #else - mLandClipper->SetInputData(mLandmarks->GetOutput()); + mLandmarkTransform = vtkSmartPointer::New(); + mLandmarkTransform->SetInputData(mLandmarks->GetOutput()); + mConcatenatedTransform->Identity(); + mConcatenatedTransform->Concatenate(mImage->GetTransform()[0]); + mConcatenatedTransform->Concatenate(mSlicingTransform); + mLandmarkTransform->SetTransform(mConcatenatedTransform->GetInverse()); + mLandClipper->SetInputConnection(mLandmarkTransform->GetOutputPort()); - mLandGlyph->SetSourceData(mCross->GetOutput()); - mLandGlyph->SetInputData(mLandClipper->GetOutput()); + mLandGlyph->SetSourceConnection(mCross->GetOutputPort()); + mLandGlyph->SetInputConnection(mLandClipper->GetOutputPort()); #endif //mLandGlyph->SetIndexModeToScalar(); //mLandGlyph->SetRange(0,1); @@ -695,11 +706,11 @@ void vvSlicer::SetLandmarks(vvLandmarks* landmarks) //mLandMapper->ScalarVisibilityOff(); mLandActor->SetMapper(mLandMapper); + mLandActor->GetProperty()->SetOpacity(0.995); //in order to get VTK to turn on the alpha-blending in OpenGL mLandActor->GetProperty()->SetColor(255,10,212); mLandActor->SetPickable(0); mLandActor->SetVisibility(true); this->UpdateDisplayExtent(); - this->GetRenderer()->AddActor(mLandActor); } } //------------------------------------------------------------------------------ @@ -707,7 +718,7 @@ void vvSlicer::SetLandmarks(vvLandmarks* landmarks) //------------------------------------------------------------------------------ //FIXME: this function leaks memory, we should fix it someday :) void vvSlicer::RemoveActor(const std::string& actor_type, int overlay_index) -{ //out << __func__ << endl; +{ if (actor_type == "vector") { Renderer->RemoveActor(mVFActor); mGlyphFilter=NULL; @@ -740,7 +751,7 @@ void vvSlicer::RemoveActor(const std::string& actor_type, int overlay_index) //------------------------------------------------------------------------------ void vvSlicer::SetVFSubSampling(int sub) -{ //out << __func__ << endl; +{ if (mVOIFilter) { mVOIFilter->SetSampleRate(mSubSampling,mSubSampling,mSubSampling); mSubSampling = sub; @@ -753,7 +764,7 @@ void vvSlicer::SetVFSubSampling(int sub) //------------------------------------------------------------------------------ void vvSlicer::SetVFScale(int scale) -{ //out << __func__ << endl; +{ mScale = scale; if (mArrow) mArrow->SetScale(mScale); @@ -764,7 +775,7 @@ void vvSlicer::SetVFScale(int scale) //------------------------------------------------------------------------------ void vvSlicer::SetVFWidth(int width) -{ //out << __func__ << endl; +{ mVFWidth = width; if (mVFActor) mVFActor->GetProperty()->SetLineWidth(mVFWidth); @@ -776,7 +787,7 @@ void vvSlicer::SetVFWidth(int width) //------------------------------------------------------------------------------ void vvSlicer::SetVFLog(int log) -{ //out << __func__ << endl; +{ mVFLog = log; if (mGlyphFilter) { mGlyphFilter->SetUseLog(mVFLog); @@ -790,7 +801,7 @@ void vvSlicer::SetVFLog(int log) //------------------------------------------------------------------------------ void vvSlicer::SetTSlice(int t, bool updateLinkedImages) -{ //out << __func__ << endl; +{ if (!updateLinkedImages) { mCurrentTSlice = t; #if VTK_MAJOR_VERSION <= 5 @@ -840,7 +851,6 @@ void vvSlicer::SetTSlice(int t, bool updateLinkedImages) #else mOverlayReslice->SetInputData( mOverlay->GetVTKImages()[mCurrentOverlayTSlice] ); #endif - // Update overlay transform mConcatenatedOverlayTransform->Identity(); mConcatenatedOverlayTransform->Concatenate(mOverlay->GetTransform()[mCurrentOverlayTSlice]); @@ -874,7 +884,7 @@ void vvSlicer::SetTSlice(int t, bool updateLinkedImages) //------------------------------------------------------------------------------ void vvSlicer::SetFusionSequenceTSlice(int t) -{ //out << __func__ << endl; +{ if (mFusion && mFusionActor->GetVisibility() && (mFusionSequenceCode>=0)) { if (mFusion->GetVTKImages().size() > (unsigned int)t) { mCurrentFusionTSlice = t; @@ -897,18 +907,18 @@ void vvSlicer::SetFusionSequenceTSlice(int t) //------------------------------------------------------------------------------ int vvSlicer::GetTSlice() -{ //out << __func__ << endl; +{ return mCurrentTSlice; } //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ int vvSlicer::GetMaxCurrentTSlice() -{ //out << __func__ << endl; +{ int t = mCurrentTSlice; - if(mOverlay) + if(mOverlay && mOverlayActor->GetVisibility()) t = std::max(t, mCurrentOverlayTSlice); - if(mFusion&& (mFusionSequenceCode<0)) //ignore fusionSequence data: for these, the times are not to be related (this way) + if(mFusion&& (mFusionSequenceCode<0) && mFusionActor->GetVisibility()) //ignore fusionSequence data: for these, the times are not to be related (this way) t = std::max(t, mCurrentFusionTSlice); return t; } @@ -916,21 +926,21 @@ int vvSlicer::GetMaxCurrentTSlice() //------------------------------------------------------------------------------ int vvSlicer::GetFusionTSlice() -{ //out << __func__ << endl; +{ return mCurrentFusionTSlice; } //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ int vvSlicer::GetOverlayTSlice() -{ //out << __func__ << endl; +{ return mCurrentOverlayTSlice; } //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ void vvSlicer::SetSliceOrientation(int orientation) -{ //out << __func__ << endl; +{ //if 2D image, force to watch in Axial View int extent[6]; #if VTK_MAJOR_VERSION <= 5 @@ -1002,7 +1012,7 @@ void vvSlicer::SetSliceOrientation(int orientation) // In other words, we change the grid of the reslice in the same way as the grid // of the displayed image in the slicing direction. void vvSlicer::AdjustResliceToSliceOrientation(vtkImageReslice *reslice) -{ //out << __func__ << endl; +{ // Reset autocrop and update output information reslice->SetOutputOriginToDefault(); reslice->SetOutputSpacingToDefault(); @@ -1040,12 +1050,15 @@ void vvSlicer::AdjustResliceToSliceOrientation(vtkImageReslice *reslice) reslice->SetOutputOrigin(origin); reslice->SetOutputSpacing(spacing); reslice->UpdateInformation(); +#if VTK_MAJOR_VERSION <= 5 + reslice->GetOutput()->UpdateInformation(); +#endif } //------------------------------------------------------------------------------ //---------------------------------------------------------------------------- int * vvSlicer::GetExtent() -{ //out << __func__ << endl; +{ int *w_ext; if (mUseReducedExtent) { w_ext = mReducedExtent; @@ -1064,7 +1077,7 @@ int * vvSlicer::GetExtent() //---------------------------------------------------------------------------- int vvSlicer::GetOrientation() -{ //out << __func__ << endl; +{ return this->SliceOrientation; } //---------------------------------------------------------------------------- @@ -1072,23 +1085,31 @@ int vvSlicer::GetOrientation() //---------------------------------------------------------------------------- void vvSlicer::UpdateDisplayExtent() -{ //out << __func__ << endl; +{ + emit UpdateDisplayExtentBegin(mSlicerNumber); vtkImageData *input = this->GetInput(); - if (!input || !this->ImageActor) { return; } - + #if VTK_MAJOR_VERSION <= 5 input->UpdateInformation(); +#else + mRegisterExtent = mImageReslice->GetOutputInformation(0)->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT()); #endif this->SetSlice( this->GetSlice() ); //SR: make sure the update let the slice in extents // Local copy of extent int w_ext[6]; +#if VTK_MAJOR_VERSION <= 5 int* ext = GetExtent(); +#else + int* ext = mImageReslice->GetOutputInformation(0)->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT()); +#endif copyExtent(ext, w_ext); - + if (mUseReducedExtent) { + copyExtent(mReducedExtent, w_ext); + } // Set slice value w_ext[ this->SliceOrientation*2 ] = this->Slice; @@ -1096,29 +1117,7 @@ void vvSlicer::UpdateDisplayExtent() // Image actor this->ImageActor->SetVisibility(mImageVisibility); -#if VTK_MAJOR_VERSION <= 5 this->ImageActor->SetDisplayExtent(w_ext); -#else - vtkSmartPointer mapperOpenGL= vtkSmartPointer::New(); - try { - mapperOpenGL = dynamic_cast(GetImageActor()->GetMapper()); - } catch (const std::bad_cast& e) { - std::cerr << e.what() << std::endl; - std::cerr << "Conversion error" << std::endl; - return; - } - if (mFirstSetSliceOrientation) { - copyExtent(ext, mRegisterExtent); - this->ImageActor->SetDisplayExtent(w_ext); //initialisation - } else { - int w_croppingRegion[6]; - copyExtent(mRegisterExtent, w_croppingRegion); - this->ImageActor->SetDisplayExtent(w_ext); - w_croppingRegion[ this->SliceOrientation*2 ] = this->Slice; - w_croppingRegion[ this->SliceOrientation*2+1 ] = this->Slice; - mapperOpenGL->SetCroppingRegion(w_croppingRegion); - } -#endif #if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10) // Fix for bug #1882 @@ -1129,11 +1128,12 @@ void vvSlicer::UpdateDisplayExtent() if (mOverlay && mOverlayVisibility) { AdjustResliceToSliceOrientation(mOverlayReslice); int overExtent[6]; - this->ConvertImageToImageDisplayExtent(input, w_ext, mOverlayReslice->GetOutput(), overExtent); #if VTK_MAJOR_VERSION <= 5 + this->ConvertImageToImageDisplayExtent(input, w_ext, mOverlayReslice->GetOutput(), overExtent); bool out = ClipDisplayedExtent(overExtent, mOverlayMapper->GetInput()->GetWholeExtent()); #else - bool out = ClipDisplayedExtent(overExtent, mOverlayMapper->GetInput()->GetInformation()->Get(vtkDataObject::DATA_EXTENT())); + this->ConvertImageToImageDisplayExtent(mImageReslice->GetOutputInformation(0), w_ext, mOverlayReslice->GetOutput(), overExtent); + bool out = ClipDisplayedExtent(overExtent, mOverlayMapper->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())); #endif mOverlayActor->SetVisibility(!out); mOverlayActor->SetDisplayExtent( overExtent ); @@ -1149,11 +1149,12 @@ void vvSlicer::UpdateDisplayExtent() if (mFusion && mFusionVisibility) { AdjustResliceToSliceOrientation(mFusionReslice); int fusExtent[6]; - this->ConvertImageToImageDisplayExtent(input, w_ext, mFusionReslice->GetOutput(), fusExtent); #if VTK_MAJOR_VERSION <= 5 + this->ConvertImageToImageDisplayExtent(input, w_ext, mFusionReslice->GetOutput(), fusExtent); bool out = ClipDisplayedExtent(fusExtent, mFusionMapper->GetInput()->GetWholeExtent()); #else - bool out = ClipDisplayedExtent(fusExtent, mFusionMapper->GetInput()->GetInformation()->Get(vtkDataObject::DATA_EXTENT())); + this->ConvertImageToImageDisplayExtent(mImageReslice->GetOutputInformation(0), w_ext, mFusionReslice->GetOutput(), fusExtent); + bool out = ClipDisplayedExtent(fusExtent, mFusionMapper->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())); #endif mFusionActor->SetVisibility(!out); mFusionActor->SetDisplayExtent( fusExtent ); @@ -1186,38 +1187,39 @@ void vvSlicer::UpdateDisplayExtent() int vfExtent[6]; #if VTK_MAJOR_VERSION <= 5 mVF->GetVTKImages()[0]->UpdateInformation(); -#else - //this->UpdateInformation(); -#endif this->ConvertImageToImageDisplayExtent(input, w_ext, mVF->GetVTKImages()[0], vfExtent); -#if VTK_MAJOR_VERSION <= 5 bool out = ClipDisplayedExtent(vfExtent, mVOIFilter->GetInput()->GetWholeExtent()); #else - bool out = ClipDisplayedExtent(vfExtent, mVOIFilter->GetInput()->GetInformation()->Get(vtkDataObject::DATA_EXTENT())); + mVOIFilter->Update(); + this->ConvertImageToImageDisplayExtent(mImageReslice->GetOutputInformation(0), w_ext, mVF->GetVTKImages()[0], vfExtent); + bool out = ClipDisplayedExtent(vfExtent, mVOIFilter->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())); #endif mVFActor->SetVisibility(!out); mVOIFilter->SetVOI(vfExtent); int orientation[3] = {1,1,1}; orientation[this->SliceOrientation] = 0; mGlyphFilter->SetOrientation(orientation[0], orientation[1], orientation[2]); - mVFMapper->Update(); - position[this->SliceOrientation] += offset; mVFActor->SetPosition(position); + mVFActor->GetProperty()->SetOpacity(0.995); //in order to get VTK to turn on the alpha-blending in OpenGL + mVFMapper->Update(); + } else if(mVF) mVFActor->SetVisibility(false); + + + double boundsT [6]; + for(unsigned int i=0; i<6; i++) + boundsT[i] = ImageActor->GetBounds()[i]; + boundsT[ this->SliceOrientation*2 ] = ImageActor->GetBounds()[ this->SliceOrientation*2 ]-fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]); + boundsT[ this->SliceOrientation*2+1 ] = ImageActor->GetBounds()[ this->SliceOrientation*2+1 ]+fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]); + // Landmarks actor if (mLandActor) { if (mClipBox) { - double bounds [6]; - for(unsigned int i=0; i<6; i++) - bounds[i] = ImageActor->GetBounds()[i]; - bounds[ this->SliceOrientation*2 ] = ImageActor->GetBounds()[ this->SliceOrientation*2 ]-fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]); - bounds[ this->SliceOrientation*2+1 ] = ImageActor->GetBounds()[ this->SliceOrientation*2+1 ]+fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]); - mClipBox->SetBounds(bounds); - UpdateLandmarks(); + RemoveLandmarks(); } position[this->SliceOrientation] = offset; @@ -1242,6 +1244,39 @@ void vvSlicer::UpdateDisplayExtent() cam->SetClippingRange(range - sumSpacing, range + sumSpacing); } } + + if (mLandActor) { + if (mClipBox) { + DisplayLandmarks(); + } + } + } + emit UpdateDisplayExtentEnd(mSlicerNumber); +} +//---------------------------------------------------------------------------- + +//---------------------------------------------------------------------------- +void vvSlicer::ConvertImageToImageDisplayExtent(vtkInformation *sourceImage, const int sourceExtent[6], + vtkImageData *targetImage, int targetExtent[6]) +{ + double dExtents[6]; + double *origin, *spacing; + origin = sourceImage->Get(vtkDataObject::ORIGIN()); + spacing = sourceImage->Get(vtkDataObject::SPACING()); + for(unsigned int i=0; i<6; i++) { + // From source voxel coordinates to world coordinates + dExtents[i] = origin[i/2] + spacing[i/2] * sourceExtent[i]; + + // From world coordinates to floating point target voxel coordinates + dExtents[i] = (dExtents[i]- targetImage->GetOrigin()[i/2]) / targetImage->GetSpacing()[i/2]; + + // Round to current slice or larger extent + if(i/2==this->GetOrientation()) + targetExtent[i] = itk::Math::Round(dExtents[i]); + else if(i%2==1) + targetExtent[i] = itk::Math::Ceil(dExtents[i]); + else + targetExtent[i] = itk::Math::Floor(dExtents[i]); } } //---------------------------------------------------------------------------- @@ -1249,7 +1284,7 @@ void vvSlicer::UpdateDisplayExtent() //---------------------------------------------------------------------------- void vvSlicer::ConvertImageToImageDisplayExtent(vtkImageData *sourceImage, const int sourceExtent[6], vtkImageData *targetImage, int targetExtent[6]) -{ //out << __func__ << endl; +{ double dExtents[6]; for(unsigned int i=0; i<6; i++) { // From source voxel coordinates to world coordinates @@ -1271,7 +1306,7 @@ void vvSlicer::ConvertImageToImageDisplayExtent(vtkImageData *sourceImage, const //---------------------------------------------------------------------------- bool vvSlicer::ClipDisplayedExtent(int extent[6], int refExtent[6]) -{ //out << __func__ << endl; +{ bool out = false; int maxBound = 6; @@ -1299,7 +1334,7 @@ bool vvSlicer::ClipDisplayedExtent(int extent[6], int refExtent[6]) //---------------------------------------------------------------------------- void vvSlicer::UpdateOrientation() -{ //out << __func__ << endl; +{ // Set the camera position vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL; if (cam) { @@ -1329,7 +1364,7 @@ void vvSlicer::UpdateOrientation() //---------------------------------------------------------------------------- void vvSlicer::SetOpacity(double s) -{ //out << __func__ << endl; +{ this->GetImageActor()->SetOpacity(s); } //---------------------------------------------------------------------------- @@ -1337,7 +1372,7 @@ void vvSlicer::SetOpacity(double s) //---------------------------------------------------------------------------- void vvSlicer::SetRenderWindow(int orientation, vtkRenderWindow * rw) -{ //out << __func__ << endl; +{ this->Superclass::SetRenderWindow(rw); this->SetupInteractor(rw->GetInteractor()); ca->SetImageActor(this->GetImageActor()); @@ -1369,7 +1404,7 @@ void vvSlicer::SetRenderWindow(int orientation, vtkRenderWindow * rw) //---------------------------------------------------------------------------- void vvSlicer::ResetCamera() -{ //out << __func__ << endl; +{ this->GetRenderer()->ResetCamera(); } //---------------------------------------------------------------------------- @@ -1377,7 +1412,7 @@ void vvSlicer::ResetCamera() //---------------------------------------------------------------------------- void vvSlicer::SetDisplayMode(bool i) -{ //out << __func__ << endl; +{ this->GetRenderer()->SetDraw(i); if (i) UpdateDisplayExtent(); } @@ -1386,7 +1421,7 @@ void vvSlicer::SetDisplayMode(bool i) //---------------------------------------------------------------------------- void vvSlicer::FlipHorizontalView() -{ //out << __func__ << endl; +{ vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL; if (cam) { double *position = cam->GetPosition(); @@ -1417,7 +1452,7 @@ void vvSlicer::FlipHorizontalView() //---------------------------------------------------------------------------- void vvSlicer::FlipVerticalView() -{ //out << __func__ << endl; +{ vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL; if (cam) { FlipHorizontalView(); @@ -1431,7 +1466,7 @@ void vvSlicer::FlipVerticalView() //---------------------------------------------------------------------------- void vvSlicer::SetColorWindow(double window) -{ //out << __func__ << endl; +{ vtkLookupTable* LUT = static_cast(this->GetWindowLevel()->GetLookupTable()); if ( LUT ) { double level = this->GetWindowLevel()->GetLevel(); @@ -1444,7 +1479,7 @@ void vvSlicer::SetColorWindow(double window) //---------------------------------------------------------------------------- void vvSlicer::SetColorLevel(double level) -{ //out << __func__ << endl; +{ vtkLookupTable* LUT = static_cast(this->GetWindowLevel()->GetLookupTable()); if ( LUT ) { double window = this->GetWindowLevel()->GetWindow(); @@ -1457,7 +1492,7 @@ void vvSlicer::SetColorLevel(double level) //---------------------------------------------------------------------------- double vvSlicer::GetOverlayColorWindow() -{ //out << __func__ << endl; +{ if(mOverlayMapper) return mOverlayMapper->GetWindow(); else @@ -1467,7 +1502,7 @@ double vvSlicer::GetOverlayColorWindow() //---------------------------------------------------------------------------- double vvSlicer::GetOverlayColorLevel() -{ //out << __func__ << endl; +{ if(mOverlayMapper) return mOverlayMapper->GetLevel(); else @@ -1477,7 +1512,7 @@ double vvSlicer::GetOverlayColorLevel() //---------------------------------------------------------------------------- void vvSlicer::SetOverlayColorWindow(double window) -{ //out << __func__ << endl; +{ if(mOverlayMapper) mOverlayMapper->SetWindow(window); } @@ -1485,7 +1520,7 @@ void vvSlicer::SetOverlayColorWindow(double window) //---------------------------------------------------------------------------- void vvSlicer::SetOverlayColorLevel(double level) -{ //out << __func__ << endl; +{ if(mOverlayMapper) mOverlayMapper->SetLevel(level); } @@ -1494,7 +1529,7 @@ void vvSlicer::SetOverlayColorLevel(double level) //---------------------------------------------------------------------------- // Returns the min an the max value in a 20%x20% region around the mouse pointer void vvSlicer::GetExtremasAroundMousePointer(double & min, double & max, vtkImageData *image, vtkTransform *transform) -{ //out << __func__ << endl; +{ //Get mouse pointer position in view coordinates double corner1[3]; double corner2[3]; @@ -1529,6 +1564,16 @@ void vvSlicer::GetExtremasAroundMousePointer(double & min, double & max, vtkImag if(iLocalExtents[i*2 ]>iLocalExtents[i*2+1]) std::swap(iLocalExtents[i*2], iLocalExtents[i*2+1]); + +#if VTK_MAJOR_VERSION > 5 + for(int j=0;j<2; j++) { + if(iLocalExtents[i*2+j]< mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[2*i]) + iLocalExtents[i*2+j] = mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[2*i]; + + if(iLocalExtents[i*2+j]> mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[2*i+1]) + iLocalExtents[i*2+j] = mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[2*i+1]; + } +#endif } vtkSmartPointer voiFilter = vtkSmartPointer::New(); @@ -1549,7 +1594,7 @@ void vvSlicer::GetExtremasAroundMousePointer(double & min, double & max, vtkImag #if VTK_MAJOR_VERSION <= 5 accFilter->SetInput(voiFilter->GetOutput()); #else - accFilter->SetInputData(voiFilter->GetOutput()); + accFilter->SetInputConnection(voiFilter->GetOutputPort(0)); #endif accFilter->Update(); @@ -1560,7 +1605,7 @@ void vvSlicer::GetExtremasAroundMousePointer(double & min, double & max, vtkImag //---------------------------------------------------------------------------- double vvSlicer::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int &ix, int &iy, int &iz, int component) -{ //out << __func__ << endl; +{ ix = lrint(X); iy = lrint(Y); iz = lrint(Z); @@ -1592,8 +1637,7 @@ double vvSlicer::GetScalarComponentAsDouble(vtkImageData *image, double X, doubl //---------------------------------------------------------------------------- void vvSlicer::Render() -{ //out << __func__ << endl; - +{ if (this->mFusion && mFusionActor->GetVisibility() && showFusionLegend) { legend->SetLookupTable(this->GetFusionMapper()->GetLookupTable()); legend->UseOpacityOn(); @@ -1606,6 +1650,7 @@ void vvSlicer::Render() } else legend->SetVisibility(0); if (ca->GetVisibility()) { + std::stringstream worldPos(" "); double pt[3]; mConcatenatedTransform->TransformPoint(mCurrent, pt); @@ -1645,7 +1690,7 @@ void vvSlicer::Render() Y <= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[3]+0.5 && Z >= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[4]-0.5 && Z <= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[5]+0.5) { - + int ix, iy, iz; double value = this->GetScalarComponentAsDouble(mImage->GetVTKImages()[mCurrentTSlice], X, Y, Z, ix, iy, iz); @@ -1707,6 +1752,7 @@ void vvSlicer::Render() std::cerr << "Conversion error" << std::endl; return; } + if (xCursor >= mapperOpenGL->GetCroppingRegion()[0]-0.5 && xCursor < mapperOpenGL->GetCroppingRegion()[1]+0.5 && yCursor >= mapperOpenGL->GetCroppingRegion()[2]-0.5 && @@ -1747,8 +1793,10 @@ void vvSlicer::Render() #endif mFusionMapper->Update(); } - if (mLandMapper) - UpdateLandmarks(); + if (mLandMapper) { + RemoveLandmarks(); + DisplayLandmarks(); + } this->GetRenderWindow()->Render(); } @@ -1757,7 +1805,7 @@ void vvSlicer::Render() //---------------------------------------------------------------------------- void vvSlicer::UpdateCursorPosition() -{ //out << __func__ << endl; +{ pdmA->SetVisibility(true); mCursor[0] = mCurrent[0]; mCursor[1] = mCurrent[1]; @@ -1768,24 +1816,43 @@ void vvSlicer::UpdateCursorPosition() //---------------------------------------------------------------------------- -void vvSlicer::UpdateLandmarks() -{ //out << __func__ << endl; - vtkPolyData *pd = static_cast(mLandClipper->GetInput()); +void vvSlicer::RemoveLandmarks() +{ + vtkPolyData *pd = static_cast(mLandmarks->GetOutput()); if (pd->GetPoints()) { - //mLandGlyph->SetRange(0,1); - //mLandGlyph->Modified(); - //mLandGlyph->Update(); - mClipBox->Modified(); - mLandClipper->Update(); - mLandMapper->Update(); - //Let's add the captions //First remove all captions: for(unsigned int i=0;iRenderer->RemoveActor2D(mLandLabelActors[i]); //allActors2D->Remove (mLandLabelActors[i]); } mLandLabelActors.clear(); + } +} +//---------------------------------------------------------------------------- + + +//---------------------------------------------------------------------------- +void vvSlicer::DisplayLandmarks() +{ + + double bounds [6]; + for(unsigned int i=0; i<6; i++) + bounds[i] = ImageActor->GetBounds()[i]; + bounds[ this->SliceOrientation*2 ] = ImageActor->GetBounds()[ this->SliceOrientation*2 ]-fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]); + bounds[ this->SliceOrientation*2+1 ] = ImageActor->GetBounds()[ this->SliceOrientation*2+1 ]+fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]); + mClipBox->SetBounds(bounds); + + + vtkPolyData *pd = static_cast(mLandmarks->GetOutput()); + if (pd->GetPoints()) { + this->GetRenderer()->AddActor(mLandActor); + //mLandGlyph->SetRange(0,1); + //mLandGlyph->Modified(); + //mLandGlyph->Update(); + mClipBox->Modified(); + mLandClipper->Update(); + mLandMapper->Update(); //Next add the captions to the displayed points for (vtkIdType id=0; idGetOutput()->GetNumberOfPoints(); id++) { double *position = mLandClipper->GetOutput()->GetPoint(id); @@ -1812,7 +1879,7 @@ void vvSlicer::UpdateLandmarks() //---------------------------------------------------------------------------- void vvSlicer::SetSlice(int slice) -{ //out << __func__ << endl; +{ int *range = this->GetSliceRange(); if (range) { if (slice < range[0]) { @@ -1838,7 +1905,7 @@ void vvSlicer::SetSlice(int slice) //---------------------------------------------------------------------------- int vvSlicer::GetTMax() -{ //out << __func__ << endl; +{ int tmax = (int)mImage->GetVTKImages().size() - 1; if(mOverlay) tmax = std::max(tmax, (int)mOverlay->GetVTKImages().size()-1); @@ -1848,7 +1915,7 @@ int vvSlicer::GetTMax() //---------------------------------------------------------------------------- void vvSlicer::SetContourSlice() -{ //out << __func__ << endl; +{ if (mSurfaceCutActors.size() > 0) for (std::vector::iterator i=mSurfaceCutActors.begin(); i!=mSurfaceCutActors.end(); i++) { @@ -1863,7 +1930,7 @@ void vvSlicer::SetContourSlice() //---------------------------------------------------------------------------- void vvSlicer::ForceUpdateDisplayExtent() -{ //out << __func__ << endl; +{ this->UpdateDisplayExtent(); } //---------------------------------------------------------------------------- @@ -1871,7 +1938,7 @@ void vvSlicer::ForceUpdateDisplayExtent() //---------------------------------------------------------------------------- int* vvSlicer::GetDisplayExtent() -{ //out << __func__ << endl; +{ return this->GetImageActor()->GetDisplayExtent(); } //---------------------------------------------------------------------------- @@ -1879,7 +1946,7 @@ int* vvSlicer::GetDisplayExtent() //---------------------------------------------------------------------------- void vvSlicer::PrintSelf(ostream& os, vtkIndent indent) -{ //out << __func__ << endl; +{ this->Superclass::PrintSelf(os, indent); } //---------------------------------------------------------------------------- @@ -1887,7 +1954,7 @@ void vvSlicer::PrintSelf(ostream& os, vtkIndent indent) //---------------------------------------------------------------------------- void vvSlicer::SetVFColor(double r, double g, double b) -{ //out << __func__ << endl; +{ double mVFColorHSV[3]; mVFColor[0] = r; mVFColor[1] = g; @@ -1905,7 +1972,7 @@ void vvSlicer::SetVFColor(double r, double g, double b) //---------------------------------------------------------------------------- void vvSlicer::SetRegisterExtent(int ext[6]) -{ //out << __func__ << endl; +{ copyExtent(ext, mRegisterExtent); } //---------------------------------------------------------------------------- @@ -1913,7 +1980,7 @@ void vvSlicer::SetRegisterExtent(int ext[6]) //---------------------------------------------------------------------------- void vvSlicer::GetRegisterExtent(int ext[6]) -{ //out << __func__ << endl; +{ copyExtent(mRegisterExtent, ext); } //----------------------------------------------------------------------------