X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=vv%2FvvSlicer.cxx;h=dc7bea75eab2d265885a1f6fd9330562cb353408;hb=40faa70ff55ab09a7d95023d44672a1c8366ee87;hp=63d4699f1f8e48aa9241e0de347749be6db2ade3;hpb=c86c03213cb8bb9f5c4830d1f96e792a13a34efe;p=clitk.git diff --git a/vv/vvSlicer.cxx b/vv/vvSlicer.cxx index 63d4699..dc7bea7 100644 --- a/vv/vvSlicer.cxx +++ b/vv/vvSlicer.cxx @@ -90,7 +90,7 @@ static void copyExtent(int* in, int* to){ } //------------------------------------------------------------------------------ vvSlicer::vvSlicer() -{ //out << __func__ << endl; +{ mFusionSequenceCode = -1; this->UnInstallPipeline(); mImage = NULL; @@ -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,7 +307,7 @@ bool vvSlicer::GetCornerAnnotationVisibility() //------------------------------------------------------------------------------ vvSlicer::~vvSlicer() -{ //out << __func__ << endl; +{ for (std::vector::iterator i=mSurfaceCutActors.begin(); i!=mSurfaceCutActors.end(); i++) delete (*i); @@ -317,14 +317,14 @@ vvSlicer::~vvSlicer() //------------------------------------------------------------------------------ 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; @@ -336,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; @@ -380,7 +380,6 @@ 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(); @@ -400,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; @@ -465,7 +464,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; @@ -532,7 +531,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; @@ -550,7 +549,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") @@ -567,7 +566,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; @@ -645,7 +644,7 @@ void vvSlicer::SetVF(vvImage::Pointer vf) //------------------------------------------------------------------------------ void vvSlicer::SetLandmarks(vvLandmarks* landmarks) -{ //out << __func__ << endl; +{ mLandmarks = landmarks; if (landmarks) { @@ -706,7 +705,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; @@ -739,7 +738,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; @@ -752,7 +751,7 @@ void vvSlicer::SetVFSubSampling(int sub) //------------------------------------------------------------------------------ void vvSlicer::SetVFScale(int scale) -{ //out << __func__ << endl; +{ mScale = scale; if (mArrow) mArrow->SetScale(mScale); @@ -763,7 +762,7 @@ void vvSlicer::SetVFScale(int scale) //------------------------------------------------------------------------------ void vvSlicer::SetVFWidth(int width) -{ //out << __func__ << endl; +{ mVFWidth = width; if (mVFActor) mVFActor->GetProperty()->SetLineWidth(mVFWidth); @@ -775,7 +774,7 @@ void vvSlicer::SetVFWidth(int width) //------------------------------------------------------------------------------ void vvSlicer::SetVFLog(int log) -{ //out << __func__ << endl; +{ mVFLog = log; if (mGlyphFilter) { mGlyphFilter->SetUseLog(mVFLog); @@ -789,7 +788,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 @@ -872,7 +871,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; @@ -895,14 +894,14 @@ void vvSlicer::SetFusionSequenceTSlice(int t) //------------------------------------------------------------------------------ int vvSlicer::GetTSlice() -{ //out << __func__ << endl; +{ return mCurrentTSlice; } //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ int vvSlicer::GetMaxCurrentTSlice() -{ //out << __func__ << endl; +{ int t = mCurrentTSlice; if(mOverlay) t = std::max(t, mCurrentOverlayTSlice); @@ -914,21 +913,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 @@ -1000,7 +999,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(); @@ -1043,7 +1042,7 @@ void vvSlicer::AdjustResliceToSliceOrientation(vtkImageReslice *reslice) //---------------------------------------------------------------------------- int * vvSlicer::GetExtent() -{ //out << __func__ << endl; +{ int *w_ext; if (mUseReducedExtent) { w_ext = mReducedExtent; @@ -1062,7 +1061,7 @@ int * vvSlicer::GetExtent() //---------------------------------------------------------------------------- int vvSlicer::GetOrientation() -{ //out << __func__ << endl; +{ return this->SliceOrientation; } //---------------------------------------------------------------------------- @@ -1070,8 +1069,7 @@ int vvSlicer::GetOrientation() //---------------------------------------------------------------------------- void vvSlicer::UpdateDisplayExtent() -{ //out << __func__ << endl; - +{ vtkImageData *input = this->GetInput(); if (!input || !this->ImageActor) { return; @@ -1086,12 +1084,15 @@ void vvSlicer::UpdateDisplayExtent() // 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; @@ -1110,11 +1111,12 @@ void vvSlicer::UpdateDisplayExtent() if (mOverlay && mOverlayVisibility) { AdjustResliceToSliceOrientation(mOverlayReslice); int overExtent[6]; - this->ConvertImageToImageDisplayExtent(mImageReslice->GetOutputInformation(0), 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, mImage->GetVTKImages()[mCurrentTSlice]->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 ); @@ -1130,11 +1132,12 @@ void vvSlicer::UpdateDisplayExtent() if (mFusion && mFusionVisibility) { AdjustResliceToSliceOrientation(mFusionReslice); int fusExtent[6]; - this->ConvertImageToImageDisplayExtent(mImageReslice->GetOutputInformation(0), 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, mImage->GetVTKImages()[mCurrentTSlice]->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 ); @@ -1167,14 +1170,12 @@ void vvSlicer::UpdateDisplayExtent() int vfExtent[6]; #if VTK_MAJOR_VERSION <= 5 mVF->GetVTKImages()[0]->UpdateInformation(); + this->ConvertImageToImageDisplayExtent(input, w_ext, mVF->GetVTKImages()[0], vfExtent); + bool out = ClipDisplayedExtent(vfExtent, mVOIFilter->GetInput()->GetWholeExtent()); #else //this->UpdateInformation(); -#endif this->ConvertImageToImageDisplayExtent(mImageReslice->GetOutputInformation(0), w_ext, mVF->GetVTKImages()[0], vfExtent); -#if VTK_MAJOR_VERSION <= 5 - bool out = ClipDisplayedExtent(vfExtent, mVOIFilter->GetInput()->GetWholeExtent()); -#else - bool out = ClipDisplayedExtent(vfExtent, mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())); + bool out = ClipDisplayedExtent(vfExtent, mVOIFilter->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())); #endif mVFActor->SetVisibility(!out); mVOIFilter->SetVOI(vfExtent); @@ -1231,7 +1232,7 @@ void vvSlicer::UpdateDisplayExtent() //---------------------------------------------------------------------------- void vvSlicer::ConvertImageToImageDisplayExtent(vtkInformation *sourceImage, const int sourceExtent[6], vtkImageData *targetImage, int targetExtent[6]) -{ //out << __func__ << endl; +{ double dExtents[6]; double *origin, *spacing; origin = sourceImage->Get(vtkDataObject::ORIGIN()); @@ -1254,9 +1255,32 @@ void vvSlicer::ConvertImageToImageDisplayExtent(vtkInformation *sourceImage, con } //---------------------------------------------------------------------------- +//---------------------------------------------------------------------------- +void vvSlicer::ConvertImageToImageDisplayExtent(vtkImageData *sourceImage, const int sourceExtent[6], + vtkImageData *targetImage, int targetExtent[6]) +{ + double dExtents[6]; + for(unsigned int i=0; i<6; i++) { + // From source voxel coordinates to world coordinates + dExtents[i] = sourceImage->GetOrigin()[i/2] + sourceImage->GetSpacing()[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]); + } +} +//---------------------------------------------------------------------------- + //---------------------------------------------------------------------------- bool vvSlicer::ClipDisplayedExtent(int extent[6], int refExtent[6]) -{ //out << __func__ << endl; +{ bool out = false; int maxBound = 6; @@ -1284,7 +1308,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) { @@ -1314,7 +1338,7 @@ void vvSlicer::UpdateOrientation() //---------------------------------------------------------------------------- void vvSlicer::SetOpacity(double s) -{ //out << __func__ << endl; +{ this->GetImageActor()->SetOpacity(s); } //---------------------------------------------------------------------------- @@ -1322,7 +1346,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()); @@ -1354,7 +1378,7 @@ void vvSlicer::SetRenderWindow(int orientation, vtkRenderWindow * rw) //---------------------------------------------------------------------------- void vvSlicer::ResetCamera() -{ //out << __func__ << endl; +{ this->GetRenderer()->ResetCamera(); } //---------------------------------------------------------------------------- @@ -1362,7 +1386,7 @@ void vvSlicer::ResetCamera() //---------------------------------------------------------------------------- void vvSlicer::SetDisplayMode(bool i) -{ //out << __func__ << endl; +{ this->GetRenderer()->SetDraw(i); if (i) UpdateDisplayExtent(); } @@ -1371,7 +1395,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(); @@ -1402,7 +1426,7 @@ void vvSlicer::FlipHorizontalView() //---------------------------------------------------------------------------- void vvSlicer::FlipVerticalView() -{ //out << __func__ << endl; +{ vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL; if (cam) { FlipHorizontalView(); @@ -1416,7 +1440,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(); @@ -1429,7 +1453,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(); @@ -1442,7 +1466,7 @@ void vvSlicer::SetColorLevel(double level) //---------------------------------------------------------------------------- double vvSlicer::GetOverlayColorWindow() -{ //out << __func__ << endl; +{ if(mOverlayMapper) return mOverlayMapper->GetWindow(); else @@ -1452,7 +1476,7 @@ double vvSlicer::GetOverlayColorWindow() //---------------------------------------------------------------------------- double vvSlicer::GetOverlayColorLevel() -{ //out << __func__ << endl; +{ if(mOverlayMapper) return mOverlayMapper->GetLevel(); else @@ -1462,7 +1486,7 @@ double vvSlicer::GetOverlayColorLevel() //---------------------------------------------------------------------------- void vvSlicer::SetOverlayColorWindow(double window) -{ //out << __func__ << endl; +{ if(mOverlayMapper) mOverlayMapper->SetWindow(window); } @@ -1470,7 +1494,7 @@ void vvSlicer::SetOverlayColorWindow(double window) //---------------------------------------------------------------------------- void vvSlicer::SetOverlayColorLevel(double level) -{ //out << __func__ << endl; +{ if(mOverlayMapper) mOverlayMapper->SetLevel(level); } @@ -1479,7 +1503,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]; @@ -1545,7 +1569,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); @@ -1577,7 +1601,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(); @@ -1743,7 +1767,7 @@ void vvSlicer::Render() //---------------------------------------------------------------------------- void vvSlicer::UpdateCursorPosition() -{ //out << __func__ << endl; +{ pdmA->SetVisibility(true); mCursor[0] = mCurrent[0]; mCursor[1] = mCurrent[1]; @@ -1755,7 +1779,7 @@ void vvSlicer::UpdateCursorPosition() //---------------------------------------------------------------------------- void vvSlicer::UpdateLandmarks() -{ //out << __func__ << endl; +{ vtkPolyData *pd = static_cast(mLandClipper->GetInput()); if (pd->GetPoints()) { //mLandGlyph->SetRange(0,1); @@ -1798,7 +1822,7 @@ void vvSlicer::UpdateLandmarks() //---------------------------------------------------------------------------- void vvSlicer::SetSlice(int slice) -{ //out << __func__ << endl; +{ int *range = this->GetSliceRange(); if (range) { if (slice < range[0]) { @@ -1824,7 +1848,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); @@ -1834,7 +1858,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++) { @@ -1849,7 +1873,7 @@ void vvSlicer::SetContourSlice() //---------------------------------------------------------------------------- void vvSlicer::ForceUpdateDisplayExtent() -{ //out << __func__ << endl; +{ this->UpdateDisplayExtent(); } //---------------------------------------------------------------------------- @@ -1857,7 +1881,7 @@ void vvSlicer::ForceUpdateDisplayExtent() //---------------------------------------------------------------------------- int* vvSlicer::GetDisplayExtent() -{ //out << __func__ << endl; +{ return this->GetImageActor()->GetDisplayExtent(); } //---------------------------------------------------------------------------- @@ -1865,7 +1889,7 @@ int* vvSlicer::GetDisplayExtent() //---------------------------------------------------------------------------- void vvSlicer::PrintSelf(ostream& os, vtkIndent indent) -{ //out << __func__ << endl; +{ this->Superclass::PrintSelf(os, indent); } //---------------------------------------------------------------------------- @@ -1873,7 +1897,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; @@ -1891,7 +1915,7 @@ void vvSlicer::SetVFColor(double r, double g, double b) //---------------------------------------------------------------------------- void vvSlicer::SetRegisterExtent(int ext[6]) -{ //out << __func__ << endl; +{ copyExtent(ext, mRegisterExtent); } //---------------------------------------------------------------------------- @@ -1899,7 +1923,7 @@ void vvSlicer::SetRegisterExtent(int ext[6]) //---------------------------------------------------------------------------- void vvSlicer::GetRegisterExtent(int ext[6]) -{ //out << __func__ << endl; +{ copyExtent(mRegisterExtent, ext); } //----------------------------------------------------------------------------