//------------------------------------------------------------------------------
vvSlicer::vvSlicer()
{
+ this->UnInstallPipeline();
mImage = NULL;
mCurrentTSlice = 0;
mUseReducedExtent = false;
mScale = 1;
mVFLog = 0;
mVFWidth = 1;
+ mVFColor[0] = 0;
+ mVFColor[1] = 1;
+ mVFColor[2] = 0;
std::string text = "F1 = sagital; F2 = coronal; F3 = axial\n";
text += "F5 = horizontal flip; F6 = vertical flip\n\n";
text += "middle button : grab image\n";
text += "right button : change windowing\n";
- crossCursor = vtkCursor2D::New();
+ crossCursor = vtkSmartPointer<vtkCursor2D>::New();
crossCursor->AllOff();
crossCursor->AxesOn();
crossCursor->SetTranslationMode(1);
crossCursor->SetRadius(2);
- pdm = vtkPolyDataMapper2D::New();
+ pdm = vtkSmartPointer<vtkPolyDataMapper2D>::New();
pdm->SetInput(crossCursor->GetOutput());
- pdmA = vtkActor2D::New();
+ pdmA = vtkSmartPointer<vtkActor2D>::New();
pdmA->SetMapper(pdm);
pdmA->GetProperty()->SetColor(255,10,212);
pdmA->SetVisibility(0);
pdmA->SetPickable(0);
- ca = vtkCornerAnnotation::New();
+ ca = vtkSmartPointer<vtkCornerAnnotation>::New();
ca->GetTextProperty()->SetColor(255,10,212);
ca->SetVisibility(1);
mFileName = "";
this->WindowLevel->Delete();
this->WindowLevel = vvImageMapToWLColors::New();
- this->InstallPipeline();
+ this->InstallPipeline();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+void vvSlicer::SetCornerAnnotationVisibility(bool s)
+{
+ ca->SetVisibility(s);
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+bool vvSlicer::GetCornerAnnotationVisibility()
+{
+ return ca->GetVisibility();
+}
+//------------------------------------------------------------------------------
+
+
//------------------------------------------------------------------------------
vvSlicer::~vvSlicer()
{
{
if (image->GetVTKImages().size()) {
mImage = image;
- this->Superclass::SetInput(image->GetVTKImages()[0]);
+ this->Superclass::SetInput(image->GetTransformedVTKImages()[0]);
- // Prevent crash when reload -> change slice if outside extent
int extent[6];
this->GetInput()->GetWholeExtent(extent);
- if (SliceOrientation == 0) {
- if (Slice >= extent[1]) {
- Slice = (extent[1]-extent[0])/2.0;
- }
- }
- if (SliceOrientation == 1) {
- if (Slice >= extent[3]) {
- Slice = (extent[3]-extent[2])/2.0;
- }
- }
- if (SliceOrientation == 2) {
- if (Slice >= extent[5]) {
- Slice = (extent[5]-extent[4])/2.0;
- }
+
+ // Prevent crash when reload -> change slice if outside extent
+ if (Slice < extent[SliceOrientation*2] || Slice>=extent[SliceOrientation*2+1]) {
+ Slice = (extent[SliceOrientation*2+1]-extent[SliceOrientation*2])/2.0;
}
+ // Make sure that the required part image has been computed
+ extent[SliceOrientation*2] = Slice;
+ extent[SliceOrientation*2+1] = Slice;
+ image->GetTransformedVTKImages()[0]->SetUpdateExtent(extent);
+ image->GetTransformedVTKImages()[0]->Update();
+
this->UpdateDisplayExtent();
+
mCurrentTSlice = 0;
ca->SetText(0,mFileName.c_str());
}
mOverlay = overlay;
if (!mOverlayMapper)
- mOverlayMapper = vtkImageMapToWindowLevelColors::New();
- mOverlayMapper->SetInput(overlay->GetVTKImages()[0]);
+ mOverlayMapper = vtkSmartPointer<vtkImageMapToWindowLevelColors>::New();
+ mOverlayMapper->SetInput(overlay->GetTransformedVTKImages()[0]);
if (!mOverlayActor) {
- mOverlayActor = vvBlendImageActor::New();
+ mOverlayActor = vtkSmartPointer<vvBlendImageActor>::New();
mOverlayActor->SetInput(mOverlayMapper->GetOutput());
mOverlayActor->SetPickable(0);
mOverlayActor->SetVisibility(false);
mFusion = fusion;
if (!mFusionMapper)
- mFusionMapper = vtkImageMapToWindowLevelColors::New();
- mFusionMapper->SetInput(fusion->GetVTKImages()[0]);
+ mFusionMapper = vtkSmartPointer<vtkImageMapToWindowLevelColors>::New();
+ mFusionMapper->SetInput(fusion->GetTransformedVTKImages()[0]);
if (!mFusionActor) {
- mFusionActor = vtkImageActor::New();
+ mFusionActor = vtkSmartPointer<vtkImageActor>::New();
mFusionActor->SetInput(mFusionMapper->GetOutput());
mFusionActor->SetPickable(0);
mFusionActor->SetVisibility(false);
mVF = vf;
if (!mAAFilter) {
- mAAFilter=vtkAssignAttribute::New();
- mVOIFilter = vtkExtractVOI::New();
+ mAAFilter= vtkSmartPointer<vtkAssignAttribute>::New();
+ mVOIFilter = vtkSmartPointer<vtkExtractVOI>::New();
mVOIFilter->SetSampleRate(mSubSampling,mSubSampling,mSubSampling);
}
- mVOIFilter->SetInput(vf->GetVTKImages()[0]);
+ mVOIFilter->SetInput(vf->GetTransformedVTKImages()[0]);
mAAFilter->SetInput(mVOIFilter->GetOutput());
///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);
if (!mArrow)
- mArrow = vvGlyphSource::New();
+ mArrow = vtkSmartPointer<vvGlyphSource>::New();
mArrow->SetGlyphTypeToSpecificArrow();
mArrow->SetScale(mScale);
mArrow->FilledOff();
// Glyph the gradient vector (with arrows)
if (!mGlyphFilter)
- mGlyphFilter = vvGlyph2D::New();
+ mGlyphFilter = vtkSmartPointer<vvGlyph2D>::New();
mGlyphFilter->SetInput(mAAFilter->GetOutput());
mGlyphFilter->SetSource(mArrow->GetOutput());
mGlyphFilter->ScalingOn();
mGlyphFilter->SetVectorModeToUseVector();
mGlyphFilter->SetColorModeToColorByVector();
+ if (!mVFColorLUT)
+ mVFColorLUT = vtkSmartPointer<vtkLookupTable>::New();
+
+ double mVFColorHSV[3];
+ vtkMath::RGBToHSV(mVFColor, mVFColorHSV);
+ mVFColorLUT->SetHueRange(mVFColorHSV[0], mVFColorHSV[0]);
+ mVFColorLUT->SetSaturationRange(mVFColorHSV[1],mVFColorHSV[1]);
+ mVFColorLUT->SetValueRange(mVFColorHSV[2], mVFColorHSV[2]);
+
if (!mVFMapper)
- mVFMapper = vtkPolyDataMapper::New();
- //mVFMapper->SetInputConnection(mGlyphFilter->GetOutputPort());
+ mVFMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mVFMapper->SetInput(mGlyphFilter->GetOutput());
mVFMapper->ImmediateModeRenderingOn();
+ mVFMapper->SetLookupTable(mVFColorLUT);
if (!mVFActor)
- mVFActor = vtkActor::New();
+ mVFActor = vtkSmartPointer<vtkActor>::New();
mVFActor->SetMapper(mVFMapper);
mVFActor->SetPickable(0);
mVFActor->GetProperty()->SetLineWidth(mVFWidth);
if (landmarks) {
if (!mCross)
- mCross = vtkCursor3D::New();
+ mCross = vtkSmartPointer<vtkCursor3D>::New();
mCross->SetFocalPoint(0.0,0.0,0.0);
mCross->SetModelBounds(-10,10,-10,10,-10,10);
mCross->AllOff();
mCross->AxesOn();
if (!mLandGlyph)
- mLandGlyph = vtkGlyph3D::New();
+ mLandGlyph = vtkSmartPointer<vtkGlyph3D>::New();
mLandGlyph->SetSource(mCross->GetOutput());
mLandGlyph->SetInput(landmarks->GetOutput());
//mLandGlyph->SetIndexModeToScalar();
mLandGlyph->SetColorModeToColorByScalar();
if (!mClipBox)
- mClipBox = vtkBox::New();
+ mClipBox = vtkSmartPointer<vtkBox>::New();
if (!mLandClipper)
- mLandClipper = vtkClipPolyData::New();
+ mLandClipper = vtkSmartPointer<vtkClipPolyData>::New();
mLandClipper->InsideOutOn();
mLandClipper->SetInput(mLandGlyph->GetOutput());
mLandClipper->SetClipFunction(mClipBox);
if (!mLandMapper)
- mLandMapper = vtkPolyDataMapper::New();
+ mLandMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mLandMapper->SetInputConnection(mLandClipper->GetOutputPort());
//mLandMapper->ScalarVisibilityOff();
if (!mLandActor)
- mLandActor = vtkActor::New();
+ mLandActor = vtkSmartPointer<vtkActor>::New();
mLandActor->SetMapper(mLandMapper);
mLandActor->GetProperty()->SetColor(255,10,212);
mLandActor->SetPickable(0);
if (mCurrentTSlice == t) return;
mCurrentTSlice = t;
- this->SetInput(mImage->GetVTKImages()[t]);
+ this->SetInput(mImage->GetTransformedVTKImages()[t]);
if (mVF && mVFActor->GetVisibility()) {
if (mVF->GetVTKImages().size() > (unsigned int)mCurrentTSlice)
- mVOIFilter->SetInput(mVF->GetVTKImages()[mCurrentTSlice]);
+ mVOIFilter->SetInput(mVF->GetTransformedVTKImages()[mCurrentTSlice]);
}
if (mOverlay && mOverlayActor->GetVisibility()) {
- if (mOverlay->GetVTKImages().size() > (unsigned int)mCurrentTSlice)
- mOverlayMapper->SetInput(mOverlay->GetVTKImages()[mCurrentTSlice]);
+ if (mOverlay->GetTransformedVTKImages().size() > (unsigned int)mCurrentTSlice)
+ mOverlayMapper->SetInput(mOverlay->GetTransformedVTKImages()[mCurrentTSlice]);
}
if (mFusion && mFusionActor->GetVisibility()) {
if (mFusion->GetVTKImages().size() > (unsigned int)mCurrentTSlice)
- mFusionMapper->SetInput(mFusion->GetVTKImages()[mCurrentTSlice]);
+ mFusionMapper->SetInput(mFusion->GetTransformedVTKImages()[mCurrentTSlice]);
}
if (mSurfaceCutActors.size() > 0)
for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
if (range)
this->Slice = static_cast<int>((range[0] + range[1]) * 0.5);
+ // Go to current cursor position
+ // double* cursorPos = GetCursorPosition();
+ // DDV(cursorPos, 3);
+ // SetCurrentPosition(cursorPos[0],cursorPos[1],cursorPos[2],cursorPos[3]);
+
this->UpdateOrientation();
this->UpdateDisplayExtent();
switch (this->SliceOrientation) {
case vtkImageViewer2::SLICE_ORIENTATION_XY:
this->ImageActor->SetDisplayExtent(
- w_ext[0], w_ext[1], w_ext[2], w_ext[3], this->Slice, this->Slice);
+ w_ext[0], w_ext[1], w_ext[2], w_ext[3], this->Slice, this->Slice);
if (mVF && mVFActor->GetVisibility()) {
int vfExtent[6];
ComputeVFDisplayedExtent(w_ext[0], w_ext[1], w_ext[2], w_ext[3], this->Slice, this->Slice,vfExtent);
bounds[1] = ImageActor->GetBounds()[1];
bounds[2] = ImageActor->GetBounds()[2];
bounds[3] = ImageActor->GetBounds()[3];
- bounds[4] = ImageActor->GetBounds()[4]-(0.9/this->GetInput()->GetSpacing()[2]);
- bounds[5] = ImageActor->GetBounds()[5]+(0.9/this->GetInput()->GetSpacing()[2]);
+ bounds[4] = ImageActor->GetBounds()[4]-fabs(0.5/this->GetInput()->GetSpacing()[2]);
+ bounds[5] = ImageActor->GetBounds()[5]+fabs(0.5/this->GetInput()->GetSpacing()[2]);
mClipBox->SetBounds(bounds);
UpdateLandmarks();
}
+ mLandActor->SetPosition(0,0,-1.5);
+ /*
if (Renderer->GetActiveCamera()->GetPosition()[2] > this->Slice)
mLandActor->SetPosition(0,0,1.5);
else
mLandActor->SetPosition(0,0,-1.5);
+ */
}
break;
case vtkImageViewer2::SLICE_ORIENTATION_XZ:
this->ImageActor->SetDisplayExtent(
- w_ext[0], w_ext[1], this->Slice, this->Slice, w_ext[4], w_ext[5]);
+ w_ext[0], w_ext[1], this->Slice, this->Slice, w_ext[4], w_ext[5]);
if (mVF && mVFActor->GetVisibility()) {
int vfExtent[6];
ComputeVFDisplayedExtent(w_ext[0], w_ext[1], this->Slice, this->Slice, w_ext[4], w_ext[5],vfExtent);
double bounds [6];
bounds[0] = ImageActor->GetBounds()[0];
bounds[1] = ImageActor->GetBounds()[1];
- bounds[2] = ImageActor->GetBounds()[2]-(0.5/this->GetInput()->GetSpacing()[1]);
- bounds[3] = ImageActor->GetBounds()[3]+(0.5/this->GetInput()->GetSpacing()[1]);
+ bounds[2] = ImageActor->GetBounds()[2]-fabs(0.5/this->GetInput()->GetSpacing()[1]);
+ bounds[3] = ImageActor->GetBounds()[3]+fabs(0.5/this->GetInput()->GetSpacing()[1]);
bounds[4] = ImageActor->GetBounds()[4];
bounds[5] = ImageActor->GetBounds()[5];
mClipBox->SetBounds(bounds);
case vtkImageViewer2::SLICE_ORIENTATION_YZ:
this->ImageActor->SetDisplayExtent(
- this->Slice, this->Slice, w_ext[2], w_ext[3], w_ext[4], w_ext[5]);
+ this->Slice, this->Slice, w_ext[2], w_ext[3], w_ext[4], w_ext[5]);
if (mVF && mVFActor->GetVisibility()) {
int vfExtent[6];
ComputeVFDisplayedExtent(this->Slice, this->Slice, w_ext[2], w_ext[3], w_ext[4], w_ext[5],vfExtent);
if (mLandActor) {
if (mClipBox) {
double bounds [6];
- bounds[0] = ImageActor->GetBounds()[0]-(0.5/this->GetInput()->GetSpacing()[0]);
- bounds[1] = ImageActor->GetBounds()[1]+(0.5/this->GetInput()->GetSpacing()[0]);
+ bounds[0] = ImageActor->GetBounds()[0]-fabs(0.5/this->GetInput()->GetSpacing()[0]);
+ bounds[1] = ImageActor->GetBounds()[1]+fabs(0.5/this->GetInput()->GetSpacing()[0]);
bounds[2] = ImageActor->GetBounds()[2];
bounds[3] = ImageActor->GetBounds()[3];
bounds[4] = ImageActor->GetBounds()[4];
double avg_spacing =
((double)spacing[0] + (double)spacing[1] + (double)spacing[2]) / 3.0;
cam->SetClippingRange(
- range - avg_spacing * 3.0, range + avg_spacing * 3.0);
+ range - avg_spacing * 3.0, range + avg_spacing * 3.0);
}
}
}
//----------------------------------------------------------------------------
void vvSlicer::ComputeVFDisplayedExtent(int x1,int x2,int y1,int y2,int z1,int z2,int vfExtent[6])
{
- vtkImageData* image=this->GetInput();
- vfExtent[0] = (( image->GetOrigin()[0] + x1*image->GetSpacing()[0] ) - mVF->GetOrigin()[0]) /
- mVF->GetSpacing()[0];
- vfExtent[1] = (( image->GetOrigin()[0] + x2*image->GetSpacing()[0] ) - mVF->GetOrigin()[0]) /
- mVF->GetSpacing()[0];
- vfExtent[2] = (( image->GetOrigin()[1] + y1*image->GetSpacing()[1] ) - mVF->GetOrigin()[1]) /
- mVF->GetSpacing()[1];
- vfExtent[3] = (( image->GetOrigin()[1] + y2*image->GetSpacing()[1] ) - mVF->GetOrigin()[1]) /
- mVF->GetSpacing()[1];
- vfExtent[4] = (( image->GetOrigin()[2] + z1*image->GetSpacing()[2] ) - mVF->GetOrigin()[2]) /
- mVF->GetSpacing()[2];
- vfExtent[5] = (( image->GetOrigin()[2] + z2*image->GetSpacing()[2] ) - mVF->GetOrigin()[2]) /
- mVF->GetSpacing()[2];
+ double dVfExtent[6];
+ vtkImageData* image = this->GetInput();
+ dVfExtent[0] = image->GetOrigin()[0] + x1*image->GetSpacing()[0];
+ dVfExtent[1] = image->GetOrigin()[0] + x2*image->GetSpacing()[0];
+ dVfExtent[2] = image->GetOrigin()[1] + y1*image->GetSpacing()[1];
+ dVfExtent[3] = image->GetOrigin()[1] + y2*image->GetSpacing()[1];
+ dVfExtent[4] = image->GetOrigin()[2] + z1*image->GetSpacing()[2];
+ dVfExtent[5] = image->GetOrigin()[2] + z2*image->GetSpacing()[2];
+
+ vtkImageData* vf = mVF->GetTransformedVTKImages()[0];
+ vf->UpdateInformation();
+ for(unsigned int i=0; i<6; i++)
+ vfExtent[i] = itk::Math::Round((dVfExtent[i]- vf->GetOrigin()[i/2]) / vf->GetSpacing()[i/2]);
ClipDisplayedExtent(vfExtent,mVOIFilter->GetInput()->GetWholeExtent());
}
//----------------------------------------------------------------------------
void vvSlicer::ComputeOverlayDisplayedExtent(int x1,int x2,int y1,int y2,int z1,int z2,int overExtent[6])
{
- vtkImageData* image=this->GetInput();
- overExtent[0] = (( image->GetOrigin()[0] + x1*image->GetSpacing()[0] ) - mOverlay->GetOrigin()[0]) /
- mOverlay->GetSpacing()[0];
- overExtent[1] = (( image->GetOrigin()[0] + x2*image->GetSpacing()[0] ) - mOverlay->GetOrigin()[0]) /
- mOverlay->GetSpacing()[0];
- overExtent[2] = (( image->GetOrigin()[1] + y1*image->GetSpacing()[1] ) - mOverlay->GetOrigin()[1]) /
- mOverlay->GetSpacing()[1];
- overExtent[3] = (( image->GetOrigin()[1] + y2*image->GetSpacing()[1] ) - mOverlay->GetOrigin()[1]) /
- mOverlay->GetSpacing()[1];
- overExtent[4] = (( image->GetOrigin()[2] + z1*image->GetSpacing()[2] ) - mOverlay->GetOrigin()[2]) /
- mOverlay->GetSpacing()[2];
- overExtent[5] = (( image->GetOrigin()[2] + z2*image->GetSpacing()[2] ) - mOverlay->GetOrigin()[2]) /
- mOverlay->GetSpacing()[2];
+ double dOverExtent[6];
+ vtkImageData* image = this->GetInput();
+ dOverExtent[0] = image->GetOrigin()[0] + x1*image->GetSpacing()[0];
+ dOverExtent[1] = image->GetOrigin()[0] + x2*image->GetSpacing()[0];
+ dOverExtent[2] = image->GetOrigin()[1] + y1*image->GetSpacing()[1];
+ dOverExtent[3] = image->GetOrigin()[1] + y2*image->GetSpacing()[1];
+ dOverExtent[4] = image->GetOrigin()[2] + z1*image->GetSpacing()[2];
+ dOverExtent[5] = image->GetOrigin()[2] + z2*image->GetSpacing()[2];
+
+ vtkImageData* overlay = mOverlay->GetTransformedVTKImages()[0];
+ overlay->UpdateInformation();
+ for(unsigned int i=0; i<6; i++)
+ overExtent[i] = itk::Math::Round((dOverExtent[i]- overlay->GetOrigin()[i/2]) / overlay->GetSpacing()[i/2]);
+
ClipDisplayedExtent(overExtent, mOverlayMapper->GetInput()->GetWholeExtent());
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::ComputeFusionDisplayedExtent(int x1,int x2,int y1,int y2,int z1,int z2,int fusExtent[6])
{
- vtkImageData* image=this->GetInput();
- fusExtent[0] = (( image->GetOrigin()[0] + x1*image->GetSpacing()[0] ) - mFusion->GetOrigin()[0]) /
- mFusion->GetSpacing()[0];
- fusExtent[1] = (( image->GetOrigin()[0] + x2*image->GetSpacing()[0] ) - mFusion->GetOrigin()[0]) /
- mFusion->GetSpacing()[0];
- fusExtent[2] = (( image->GetOrigin()[1] + y1*image->GetSpacing()[1] ) - mFusion->GetOrigin()[1]) /
- mFusion->GetSpacing()[1];
- fusExtent[3] = (( image->GetOrigin()[1] + y2*image->GetSpacing()[1] ) - mFusion->GetOrigin()[1]) /
- mFusion->GetSpacing()[1];
- fusExtent[4] = (( image->GetOrigin()[2] + z1*image->GetSpacing()[2] ) - mFusion->GetOrigin()[2]) /
- mFusion->GetSpacing()[2];
- fusExtent[5] = (( image->GetOrigin()[2] + z2*image->GetSpacing()[2] ) - mFusion->GetOrigin()[2]) /
- mFusion->GetSpacing()[2];
+ double dFusExtent[6];
+ vtkImageData* image = this->GetInput();
+ dFusExtent[0] = image->GetOrigin()[0] + x1*image->GetSpacing()[0];
+ dFusExtent[1] = image->GetOrigin()[0] + x2*image->GetSpacing()[0];
+ dFusExtent[2] = image->GetOrigin()[1] + y1*image->GetSpacing()[1];
+ dFusExtent[3] = image->GetOrigin()[1] + y2*image->GetSpacing()[1];
+ dFusExtent[4] = image->GetOrigin()[2] + z1*image->GetSpacing()[2];
+ dFusExtent[5] = image->GetOrigin()[2] + z2*image->GetSpacing()[2];
+
+ vtkImageData* fusion = mFusion->GetTransformedVTKImages()[0];
+ fusion->UpdateInformation();
+ for(unsigned int i=0; i<6; i++)
+ fusExtent[i] = itk::Math::Round((dFusExtent[i]- fusion->GetOrigin()[i/2]) / fusion->GetSpacing()[i/2]);
+
ClipDisplayedExtent(fusExtent, mFusionMapper->GetInput()->GetWholeExtent());
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::ResetCamera()
{
- if (this->GetInput()) {
- double* input_bounds=this->GetInput()->GetBounds();
- double bmax=input_bounds[1]-input_bounds[0];
- if (bmax < input_bounds[3]-input_bounds[2]) bmax=input_bounds[3]-input_bounds[2];
- if (bmax < input_bounds[5]-input_bounds[4]) bmax=input_bounds[5]-input_bounds[4];
- this->GetRenderer()->ResetCamera();
- this->GetRenderer()->GetActiveCamera()->SetParallelScale(bmax/2);
- }
+ this->GetRenderer()->ResetCamera();
}
//----------------------------------------------------------------------------
std::swap(iLocalExtents[i*2], iLocalExtents[i*2+1]);
}
- vtkSmartPointer<vtkExtractVOI> voiFilter = vtkExtractVOI::New();
+ vtkSmartPointer<vtkExtractVOI> voiFilter = vtkSmartPointer<vtkExtractVOI>::New();
voiFilter->SetInput(this->GetInput());
voiFilter->SetVOI(iLocalExtents);
voiFilter->Update();
return;
}
- vtkSmartPointer<vtkImageAccumulate> accFilter = vtkImageAccumulate::New();
+ vtkSmartPointer<vtkImageAccumulate> accFilter = vtkSmartPointer<vtkImageAccumulate>::New();
accFilter->SetInput(voiFilter->GetOutput());
accFilter->Update();
}
//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+double vvSlicer::GetScalarComponentAsDouble(vtkImageData *image, int X, double Y, double Z, int &ix, int &iy, int &iz, int component)
+{
+ ix = lrint(X);
+ iy = lrint(Y);
+ iz = lrint(Z);
+ if (ix < image->GetWholeExtent()[0] ||
+ ix > image->GetWholeExtent()[1] ||
+ iy < image->GetWholeExtent()[2] ||
+ iy > image->GetWholeExtent()[3] ||
+ iz < image->GetWholeExtent()[4] ||
+ iz > image->GetWholeExtent()[5] )
+ return sqrt(-1.);
+
+ image->SetUpdateExtent(ix, ix, iy, iy, iz, iz);
+ image->Update();
+ return image->GetScalarComponentAsDouble(ix, iy, iz, component);
+}
+//----------------------------------------------------------------------------
+
//----------------------------------------------------------------------------
void vvSlicer::Render()
{
- // DD("vvSlicer::Render");
- // DD(SliceOrientation);
if (this->GetWindowLevel()->GetLookupTable() && !this->mOverlay && !this->mFusion) {
legend->SetLookupTable(this->GetWindowLevel()->GetLookupTable());
legend->SetVisibility(1);
Y <= this->GetInput()->GetWholeExtent()[3] &&
Z >= this->GetInput()->GetWholeExtent()[4] &&
Z <= this->GetInput()->GetWholeExtent()[5]) {
+ int ix, iy, iz;
+ double value = this->GetScalarComponentAsDouble(this->GetInput(), X, Y, Z, ix, iy, iz);
+
std::stringstream pixel1;
std::stringstream pixel2;
std::stringstream pixel3;
std::stringstream temps;
- pixel1 << (int)X;
- pixel2 << (int)Y;
- pixel3 << (int)Z;
+ pixel1 << ix;
+ pixel2 << iy;
+ pixel3 << iz;
temps << mCurrentTSlice;
- double value = this->GetInput()->GetScalarComponentAsDouble(lrint(X),
- lrint(Y),
- lrint(Z),0);
std::stringstream val;
val << value;
worldPos += "data value : " + val.str();
worldPos += "\n mm : " + world1.str() + " " + world2.str() + " " +
- world3.str() + " " + temps.str();
+ world3.str() + " " + temps.str();
worldPos += "\n pixel : " + pixel1.str() + " " + pixel2.str() + " " +
- pixel3.str() + " " + temps.str();
+ pixel3.str() + " " + temps.str();
}
ca->SetText(1,worldPos.c_str());
}
if (mOverlay && mOverlayActor->GetVisibility()) {
mOverlayMapper->SetWindow(this->GetColorWindow());
mOverlayMapper->SetLevel(this->GetColorLevel());
+ mOverlayMapper->GetOutput()->SetUpdateExtent(mOverlayActor->GetDisplayExtent());
+ mOverlayMapper->GetOutput()->Update();
mOverlayMapper->Update();
}
if (mLandMapper)
this->Modified();
this->UpdateDisplayExtent();
- // DD("SetSlice de slicer = Render");
-
// Seems to work without this line
// this->Render();
}
}
//----------------------------------------------------------------------------
-
-
-
-
-
+//----------------------------------------------------------------------------
+void vvSlicer::SetVFColor(double r, double g, double b)
+{
+ double mVFColorHSV[3];
+ mVFColor[0] = r;
+ mVFColor[1] = g;
+ mVFColor[2] = b;
+
+ vtkMath::RGBToHSV(mVFColor, mVFColorHSV);
+ mVFColorLUT->SetHueRange(mVFColorHSV[0], mVFColorHSV[0]);
+ mVFColorLUT->SetSaturationRange(mVFColorHSV[1],mVFColorHSV[1]);
+ mVFColorLUT->SetValueRange(mVFColorHSV[2], mVFColorHSV[2]);
+
+ this->Render();
+}