#include <vtkAssignAttribute.h>
#include <vtkImageAccumulate.h>
#include <vtkImageReslice.h>
-#include <vtkOpenGLImageSliceMapper.h>
#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
+# include <vtkOpenGLImageSliceMapper.h>
# include <vtkImageMapper3D.h>
# include <vtkImageSliceMapper.h>
#endif
}
//------------------------------------------------------------------------------
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;
//------------------------------------------------------------------------------
vtkImageMapToWindowLevelColors* vvSlicer::GetOverlayMapper()
-{ //out << __func__ << endl;
+{
return mOverlayMapper.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vvBlendImageActor* vvSlicer::GetOverlayActor()
-{ //out << __func__ << endl;
+{
return mOverlayActor.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkImageMapToColors* vvSlicer::GetFusionMapper()
-{ //out << __func__ << endl;
+{
return mFusionMapper.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkImageActor* vvSlicer::GetFusionActor()
-{ //out << __func__ << endl;
+{
return mFusionActor.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkActor* vvSlicer::GetVFActor()
-{ //out << __func__ << endl;
+{
return mVFActor.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkCornerAnnotation* vvSlicer::GetAnnotation()
-{ //out << __func__ << endl;
+{
return ca.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::EnableReducedExtent(bool b)
-{ //out << __func__ << endl;
+{
mUseReducedExtent = b;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetReducedExtent(int * ext)
-{ //out << __func__ << endl;
+{
copyExtent(ext, mReducedExtent);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::AddContour(vvMesh::Pointer contour,bool propagate)
-{ //out << __func__ << endl;
+{
mSurfaceCutActors.push_back(new vvMeshActor());
if (propagate)
//------------------------------------------------------------------------------
void vvSlicer::ToggleContourSuperposition()
-{ //out << __func__ << endl;
+{
for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
i!=mSurfaceCutActors.end(); i++)
(*i)->ToggleSuperposition();
//------------------------------------------------------------------------------
void vvSlicer::SetCursorColor(int r,int g, int b)
-{ //out << __func__ << endl;
+{
pdmA->GetProperty()->SetColor(r,g,b);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetCursorVisibility(bool s)
-{ //out << __func__ << endl;
+{
pdmA->SetVisibility(s);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool vvSlicer::GetCursorVisibility()
-{ //out << __func__ << endl;
+{
return pdmA->GetVisibility();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetCornerAnnotationVisibility(bool s)
-{ //out << __func__ << endl;
+{
ca->SetVisibility(s);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool vvSlicer::GetCornerAnnotationVisibility()
-{ //out << __func__ << endl;
+{
return ca->GetVisibility();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vvSlicer::~vvSlicer()
-{ //out << __func__ << endl;
+{
for (std::vector<vvMeshActor*>::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;
//------------------------------------------------------------------------------
void vvSlicer::SetImage(vvImage::Pointer image)
-{ //out << __func__ << endl;
+{
if (image->GetVTKImages().size()) {
mImage = 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
//------------------------------------------------------------------------------
void vvSlicer::SetOverlay(vvImage::Pointer overlay)
-{ //out << __func__ << endl;
+{
if (overlay->GetVTKImages().size()) {
mOverlay = overlay;
mOverlayVisibility = true;
mOverlayReslice->SetResliceTransform(mConcatenatedOverlayTransform);
#if VTK_MAJOR_VERSION <= 5
mOverlayReslice->SetInput(0, mOverlay->GetFirstVTKImageData());
+ mImageReslice->UpdateInformation();
#else
mOverlayReslice->SetInputData(0, mOverlay->GetFirstVTKImageData());
#endif
//------------------------------------------------------------------------------
void vvSlicer::SetFusion(vvImage::Pointer fusion, int fusionSequenceCode)
-{ //out << __func__ << endl;
+{
mFusionSequenceCode = fusionSequenceCode;
if (fusion->GetVTKImages().size()) {
mFusion = fusion;
mFusionReslice->SetResliceTransform(mConcatenatedFusionTransform);
#if VTK_MAJOR_VERSION <= 5
mFusionReslice->SetInput(0, mFusion->GetFirstVTKImageData());
+ mFusionReslice->UpdateInformation();
#else
mFusionReslice->SetInputData(0, mFusion->GetFirstVTKImageData());
#endif
//------------------------------------------------------------------------------
bool vvSlicer::GetActorVisibility(const std::string& actor_type, int overlay_index)
-{ //out << __func__ << endl;
+{
bool vis = false;
if (actor_type == "image")
vis = mImageVisibility;
//------------------------------------------------------------------------------
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")
//------------------------------------------------------------------------------
void vvSlicer::SetVF(vvImage::Pointer vf)
-{ //out << __func__ << endl;
+{
if (vf->GetVTKImages().size()) {
mVF = vf;
mVFVisibility = true;
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);
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();
#if VTK_MAJOR_VERSION <= 5
mVFMapper->SetInput(mGlyphFilter->GetOutput());
#else
- mVFMapper->SetInputData(mGlyphFilter->GetOutput());
+ mVFMapper->SetInputConnection(mGlyphFilter->GetOutputPort());
#endif
mVFMapper->ImmediateModeRenderingOn();
mVFMapper->SetLookupTable(mVFColorLUT);
//------------------------------------------------------------------------------
void vvSlicer::SetLandmarks(vvLandmarks* landmarks)
-{ //out << __func__ << endl;
+{
mLandmarks = landmarks;
if (landmarks) {
mLandClipper->SetClipFunction(mClipBox);
mLandClipper->InsideOutOn();
#if VTK_MAJOR_VERSION <= 5
- mLandClipper->SetInput(mLandmarks->GetOutput());
+ mLandmarkTransform = vtkSmartPointer<vtkTransformPolyDataFilter>::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<vtkTransformPolyDataFilter>::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);
//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);
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//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;
//------------------------------------------------------------------------------
void vvSlicer::SetVFSubSampling(int sub)
-{ //out << __func__ << endl;
+{
if (mVOIFilter) {
mVOIFilter->SetSampleRate(mSubSampling,mSubSampling,mSubSampling);
mSubSampling = sub;
//------------------------------------------------------------------------------
void vvSlicer::SetVFScale(int scale)
-{ //out << __func__ << endl;
+{
mScale = scale;
if (mArrow)
mArrow->SetScale(mScale);
//------------------------------------------------------------------------------
void vvSlicer::SetVFWidth(int width)
-{ //out << __func__ << endl;
+{
mVFWidth = width;
if (mVFActor)
mVFActor->GetProperty()->SetLineWidth(mVFWidth);
//------------------------------------------------------------------------------
void vvSlicer::SetVFLog(int log)
-{ //out << __func__ << endl;
+{
mVFLog = log;
if (mGlyphFilter) {
mGlyphFilter->SetUseLog(mVFLog);
//------------------------------------------------------------------------------
void vvSlicer::SetTSlice(int t, bool updateLinkedImages)
-{ //out << __func__ << endl;
+{
if (!updateLinkedImages) {
mCurrentTSlice = t;
#if VTK_MAJOR_VERSION <= 5
//------------------------------------------------------------------------------
void vvSlicer::SetFusionSequenceTSlice(int t)
-{ //out << __func__ << endl;
+{
if (mFusion && mFusionActor->GetVisibility() && (mFusionSequenceCode>=0)) {
if (mFusion->GetVTKImages().size() > (unsigned int)t) {
mCurrentFusionTSlice = 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;
}
//------------------------------------------------------------------------------
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
// 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();
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;
//----------------------------------------------------------------------------
int vvSlicer::GetOrientation()
-{ //out << __func__ << endl;
+{
return this->SliceOrientation;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
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;
// Image actor
this->ImageActor->SetVisibility(mImageVisibility);
this->ImageActor->SetDisplayExtent(w_ext);
-#if VTK_MAJOR_VERSION >= 6
- vtkSmartPointer<vtkOpenGLImageSliceMapper> mapperOpenGL= vtkSmartPointer<vtkOpenGLImageSliceMapper>::New();
- try {
- mapperOpenGL = dynamic_cast<vtkOpenGLImageSliceMapper*>(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);
- } else {
- int w_croppingRegion[6];
- copyExtent(mRegisterExtent, w_croppingRegion);
- 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
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, this->GetExtent());
+ 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 );
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, this->GetExtent());
+ 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 );
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;
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<double>(dExtents[i]);
+ else if(i%2==1)
+ targetExtent[i] = itk::Math::Ceil<double>(dExtents[i]);
+ else
+ targetExtent[i] = itk::Math::Floor<double>(dExtents[i]);
}
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
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
//----------------------------------------------------------------------------
bool vvSlicer::ClipDisplayedExtent(int extent[6], int refExtent[6])
-{ //out << __func__ << endl;
+{
bool out = false;
int maxBound = 6;
//----------------------------------------------------------------------------
void vvSlicer::UpdateOrientation()
-{ //out << __func__ << endl;
+{
// Set the camera position
vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
if (cam) {
//----------------------------------------------------------------------------
void vvSlicer::SetOpacity(double s)
-{ //out << __func__ << endl;
+{
this->GetImageActor()->SetOpacity(s);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::SetRenderWindow(int orientation, vtkRenderWindow * rw)
-{ //out << __func__ << endl;
+{
this->Superclass::SetRenderWindow(rw);
this->SetupInteractor(rw->GetInteractor());
ca->SetImageActor(this->GetImageActor());
//----------------------------------------------------------------------------
void vvSlicer::ResetCamera()
-{ //out << __func__ << endl;
+{
this->GetRenderer()->ResetCamera();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::SetDisplayMode(bool i)
-{ //out << __func__ << endl;
+{
this->GetRenderer()->SetDraw(i);
if (i) UpdateDisplayExtent();
}
//----------------------------------------------------------------------------
void vvSlicer::FlipHorizontalView()
-{ //out << __func__ << endl;
+{
vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
if (cam) {
double *position = cam->GetPosition();
//----------------------------------------------------------------------------
void vvSlicer::FlipVerticalView()
-{ //out << __func__ << endl;
+{
vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
if (cam) {
FlipHorizontalView();
//----------------------------------------------------------------------------
void vvSlicer::SetColorWindow(double window)
-{ //out << __func__ << endl;
+{
vtkLookupTable* LUT = static_cast<vtkLookupTable*>(this->GetWindowLevel()->GetLookupTable());
if ( LUT ) {
double level = this->GetWindowLevel()->GetLevel();
//----------------------------------------------------------------------------
void vvSlicer::SetColorLevel(double level)
-{ //out << __func__ << endl;
+{
vtkLookupTable* LUT = static_cast<vtkLookupTable*>(this->GetWindowLevel()->GetLookupTable());
if ( LUT ) {
double window = this->GetWindowLevel()->GetWindow();
//----------------------------------------------------------------------------
double vvSlicer::GetOverlayColorWindow()
-{ //out << __func__ << endl;
+{
if(mOverlayMapper)
return mOverlayMapper->GetWindow();
else
//----------------------------------------------------------------------------
double vvSlicer::GetOverlayColorLevel()
-{ //out << __func__ << endl;
+{
if(mOverlayMapper)
return mOverlayMapper->GetLevel();
else
//----------------------------------------------------------------------------
void vvSlicer::SetOverlayColorWindow(double window)
-{ //out << __func__ << endl;
+{
if(mOverlayMapper)
mOverlayMapper->SetWindow(window);
}
//----------------------------------------------------------------------------
void vvSlicer::SetOverlayColorLevel(double level)
-{ //out << __func__ << endl;
+{
if(mOverlayMapper)
mOverlayMapper->SetLevel(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];
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<vtkExtractVOI> voiFilter = vtkSmartPointer<vtkExtractVOI>::New();
//----------------------------------------------------------------------------
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);
image->SetUpdateExtent(ix, ix, iy, iy, iz, iz);
image->Update();
#else
- if (ix < image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[0] ||
- ix > image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[1] ||
- iy < image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[2] ||
- iy > image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[3] ||
- iz < image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[4] ||
- iz > image->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[5] )
+ if (ix < mImageReslice->GetOutputInformation(0)->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[0] ||
+ ix > mImageReslice->GetOutputInformation(0)->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[1] ||
+ iy < mImageReslice->GetOutputInformation(0)->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[2] ||
+ iy > mImageReslice->GetOutputInformation(0)->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[3] ||
+ iz < mImageReslice->GetOutputInformation(0)->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[4] ||
+ iz > mImageReslice->GetOutputInformation(0)->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT())[5] )
return std::numeric_limits<double>::quiet_NaN();
//image->SetUpdateExtent(ix, ix, iy, iy, iz, iz);
//image->Update();
#endif
-
return image->GetScalarComponentAsDouble(ix, iy, iz, component);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::Render()
-{ //out << __func__ << endl;
-
+{
if (this->mFusion && mFusionActor->GetVisibility() && showFusionLegend) {
legend->SetLookupTable(this->GetFusionMapper()->GetLookupTable());
legend->UseOpacityOn();
} else legend->SetVisibility(0);
if (ca->GetVisibility()) {
+
std::stringstream worldPos(" ");
- double pt[3];
- mConcatenatedTransform->TransformPoint(mCurrent, pt);
- double X = (pt[0] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[0])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[0];
- double Y = (pt[1] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[1])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[1];
- double Z = (pt[2] - mImage->GetVTKImages()[mCurrentTSlice]->GetOrigin()[2])/mImage->GetVTKImages()[mCurrentTSlice]->GetSpacing()[2];
+ double X = (mCurrent[0] - this->GetInput()->GetOrigin()[0])/this->GetInput()->GetSpacing()[0];
+ double Y = (mCurrent[1] - this->GetInput()->GetOrigin()[1])/this->GetInput()->GetSpacing()[1];
+ double Z = (mCurrent[2] - this->GetInput()->GetOrigin()[2])/this->GetInput()->GetSpacing()[2];
#if VTK_MAJOR_VERSION <= 5
- if (X >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[0]-0.5 &&
- X <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[1]+0.5 &&
- Y >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[2]-0.5 &&
- Y <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[3]+0.5 &&
- Z >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[4]-0.5 &&
- Z <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[5]+0.5) {
-
-
- int ix, iy, iz;
- double value = this->GetScalarComponentAsDouble(mImage->GetVTKImages()[mCurrentTSlice], X, Y, Z, ix, iy, iz);
-
- if(ImageActor->GetVisibility())
- worldPos << "data value : " << value << std::endl;
-
- worldPos << "mm : " << lrint(mCurrentBeforeSlicingTransform[0]) << ' '
- << lrint(mCurrentBeforeSlicingTransform[1]) << ' '
- << lrint(mCurrentBeforeSlicingTransform[2]) << ' '
- << mCurrentTSlice
- << std::endl;
- worldPos << "pixel : " << ix << ' '
- << iy << ' '
- << iz << ' '
- << mCurrentTSlice
- << std::endl;
- }
+ if (X >= this->GetInput()->GetWholeExtent()[0]-0.5 &&
+ X <= this->GetInput()->GetWholeExtent()[1]+0.5 &&
+ Y >= this->GetInput()->GetWholeExtent()[2]-0.5 &&
+ Y <= this->GetInput()->GetWholeExtent()[3]+0.5 &&
+ Z >= this->GetInput()->GetWholeExtent()[4]-0.5 &&
+ Z <= this->GetInput()->GetWholeExtent()[5]+0.5) {
#else
- if (X >= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[0]-0.5 &&
- X <= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[1]+0.5 &&
- Y >= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[2]-0.5 &&
- 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 extentImageReslice[6];
+ this->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
int ix, iy, iz;
- double value = this->GetScalarComponentAsDouble(mImage->GetVTKImages()[mCurrentTSlice], X, Y, Z, ix, iy, iz);
+ double value = this->GetScalarComponentAsDouble(this->GetInput(), X, Y, Z, ix, iy, iz);
if(ImageActor->GetVisibility())
worldPos << "data value : " << value << std::endl;
-
- worldPos << "mm : " << lrint(mCurrentBeforeSlicingTransform[0]) << ' '
- << lrint(mCurrentBeforeSlicingTransform[1]) << ' '
- << lrint(mCurrentBeforeSlicingTransform[2]) << ' '
+ worldPos << "mm : " << lrint(mCurrent[0]) << ' '
+ << lrint(mCurrent[1]) << ' '
+ << lrint(mCurrent[2]) << ' '
<< mCurrentTSlice
<< std::endl;
worldPos << "pixel : " << ix << ' '
<< std::endl;
}
-#endif
ca->SetText(1,worldPos.str().c_str());
std::stringstream slicePos;
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 &&
#endif
mFusionMapper->Update();
}
- if (mLandMapper)
- UpdateLandmarks();
+ if (mLandMapper) {
+ RemoveLandmarks();
+ DisplayLandmarks();
+ }
this->GetRenderWindow()->Render();
}
//----------------------------------------------------------------------------
void vvSlicer::UpdateCursorPosition()
-{ //out << __func__ << endl;
+{
pdmA->SetVisibility(true);
mCursor[0] = mCurrent[0];
mCursor[1] = mCurrent[1];
//----------------------------------------------------------------------------
-void vvSlicer::UpdateLandmarks()
-{ //out << __func__ << endl;
- vtkPolyData *pd = static_cast<vtkPolyData*>(mLandClipper->GetInput());
+void vvSlicer::RemoveLandmarks()
+{
+ vtkPolyData *pd = static_cast<vtkPolyData*>(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;i<mLandLabelActors.size();i++) {
this->Renderer->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<vtkPolyData*>(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; id<mLandClipper->GetOutput()->GetNumberOfPoints(); id++) {
double *position = mLandClipper->GetOutput()->GetPoint(id);
//----------------------------------------------------------------------------
void vvSlicer::SetSlice(int slice)
-{ //out << __func__ << endl;
+{
int *range = this->GetSliceRange();
if (range) {
if (slice < range[0]) {
//----------------------------------------------------------------------------
int vvSlicer::GetTMax()
-{ //out << __func__ << endl;
+{
int tmax = (int)mImage->GetVTKImages().size() - 1;
if(mOverlay)
tmax = std::max(tmax, (int)mOverlay->GetVTKImages().size()-1);
//----------------------------------------------------------------------------
void vvSlicer::SetContourSlice()
-{ //out << __func__ << endl;
+{
if (mSurfaceCutActors.size() > 0)
for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
i!=mSurfaceCutActors.end(); i++) {
//----------------------------------------------------------------------------
void vvSlicer::ForceUpdateDisplayExtent()
-{ //out << __func__ << endl;
+{
this->UpdateDisplayExtent();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
int* vvSlicer::GetDisplayExtent()
-{ //out << __func__ << endl;
+{
return this->GetImageActor()->GetDisplayExtent();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::PrintSelf(ostream& os, vtkIndent indent)
-{ //out << __func__ << endl;
+{
this->Superclass::PrintSelf(os, indent);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::SetVFColor(double r, double g, double b)
-{ //out << __func__ << endl;
+{
double mVFColorHSV[3];
mVFColor[0] = r;
mVFColor[1] = g;
//----------------------------------------------------------------------------
void vvSlicer::SetRegisterExtent(int ext[6])
-{ //out << __func__ << endl;
+{
copyExtent(ext, mRegisterExtent);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::GetRegisterExtent(int ext[6])
-{ //out << __func__ << endl;
+{
copyExtent(mRegisterExtent, ext);
}
//----------------------------------------------------------------------------
git://git.creatis.insa-lyon.fr / clitk.git / blobdiff