#include <vtkAssignAttribute.h>
#include <vtkImageAccumulate.h>
#include <vtkImageReslice.h>
+#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
+# include <vtkImageMapper3D.h>
+#endif
vtkCxxRevisionMacro(vvSlicer, "DummyRevision");
vtkStandardNewMacro(vvSlicer);
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 += "0,1,2,3,4,5 : preset windowing\n";
- text += "6,7,8,9 : preset colormap\n";
- text += "z : local windowing\n";
- text += "r : reset view\n";
- text += "l : reload image\n";
- text += "f : fly to mouse position\n";
- text += "g : go to cross hair position\n\n";
- text += "Up,down : change slice\n";
- text += "Left,right : change tenporal slice\n\n";
- text += "Scrollbar (or w/x) : zoom in/out\n";
- text += "left button : synchronize all views\n";
- text += "middle button : grab image\n";
- text += "right button : change windowing\n";
-
crossCursor = vtkSmartPointer<vtkCursor2D>::New();
crossCursor->AllOff();
crossCursor->AxesOn();
legend->SetVisibility(0);
legend->SetLabelFormat("%.1f");
this->GetRenderer()->AddActor(legend);
+ showFusionLegend = false;
this->WindowLevel->Delete();
this->WindowLevel = vvImageMapToWLColors::New();
this->InstallPipeline();
+
+ mLinkOverlayWindowLevel = true;
+
+#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
+ this->GetImageActor()->GetMapper()->BorderOn();
+#endif
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
-vtkImageMapToWindowLevelColors* vvSlicer::GetFusionMapper()
+vtkImageMapToColors* vvSlicer::GetFusionMapper()
{
return mFusionMapper.GetPointer();
}
mOverlayActor = vtkSmartPointer<vvBlendImageActor>::New();
mOverlayActor->SetInput(mOverlayMapper->GetOutput());
mOverlayActor->SetPickable(0);
- mOverlayActor->SetVisibility(false);
+ mOverlayActor->SetVisibility(true);
mOverlayActor->SetOpacity(0.5);
- }
+#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
+ mOverlayActor->GetMapper()->BorderOn();
+#endif
+ }
//stupid but necessary : the Overlay need to be rendered before fusion
if (mFusionActor) {
this->GetRenderer()->AddActor(mOverlayActor);
//Synchronize orientation and slice
- this->SetSliceOrientation(this->SliceOrientation);
+ AdjustResliceToSliceOrientation(mOverlayReslice);
+ this->UpdateDisplayExtent();
this->SetTSlice(mCurrentTSlice);
}
}
mFusionReslice->SetInput(0, mFusion->GetFirstVTKImageData());
if (!mFusionMapper)
- mFusionMapper = vtkSmartPointer<vtkImageMapToWindowLevelColors>::New();
+ mFusionMapper = vtkSmartPointer<vtkImageMapToColors>::New();
+
+ vtkSmartPointer<vtkLookupTable> lut = vtkLookupTable::New();
+ lut->SetRange(0, 1);
+ lut->SetValueRange(0, 1);
+ lut->SetSaturationRange(0, 0);
+ lut->Build();
+ mFusionMapper->SetLookupTable(lut);
mFusionMapper->SetInput(mFusionReslice->GetOutput());
if (!mFusionActor) {
mFusionActor = vtkSmartPointer<vtkImageActor>::New();
mFusionActor->SetInput(mFusionMapper->GetOutput());
mFusionActor->SetPickable(0);
- mFusionActor->SetVisibility(false);
+ mFusionActor->SetVisibility(true);
mFusionActor->SetOpacity(0.7);
+#if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
+ mFusionActor->GetMapper()->BorderOn();
+#endif
this->GetRenderer()->AddActor(mFusionActor);
}
//Synchronize orientation and slice
- this->SetSliceOrientation(this->SliceOrientation);
+ AdjustResliceToSliceOrientation(mFusionReslice);
+ this->UpdateDisplayExtent();
this->SetTSlice(mCurrentTSlice);
}
}
//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+bool vvSlicer::GetActorVisibility(const std::string& actor_type, int overlay_index)
+{
+ bool vis = false;
+ if (actor_type == "image") {
+ vis = this->ImageActor->GetVisibility();
+ }
+ else if (actor_type == "vector") {
+ vis = this->mVFActor->GetVisibility();
+ }
+ else if (actor_type == "overlay") {
+ vis = this->mOverlayActor->GetVisibility();
+ }
+ else if (actor_type == "fusion") {
+ vis = this->mFusionActor->GetVisibility();
+ }
+ else if (actor_type == "contour")
+ vis = this->mSurfaceCutActors[overlay_index]->GetActor()->GetVisibility();
+
+ return vis;
+}
+//------------------------------------------------------------------------------
+
//------------------------------------------------------------------------------
void vvSlicer::SetActorVisibility(const std::string& actor_type, int overlay_index ,bool vis)
{
- if (actor_type == "vector") {
+ if (actor_type == "image") {
+ this->ImageActor->SetVisibility(vis);
+ }
+ else if (actor_type == "vector") {
this->mVFActor->SetVisibility(vis);
}
- if (actor_type == "overlay") {
+ else if (actor_type == "overlay") {
this->mOverlayActor->SetVisibility(vis);
}
- if (actor_type == "fusion") {
+ else if (actor_type == "fusion") {
this->mFusionActor->SetVisibility(vis);
}
- if (actor_type == "contour")
+ else if (actor_type == "contour")
this->mSurfaceCutActors[overlay_index]->GetActor()->SetVisibility(vis);
UpdateDisplayExtent();
}
//------------------------------------------------------------------------------
-
//------------------------------------------------------------------------------
void vvSlicer::SetVF(vvImage::Pointer vf)
{
else if ((unsigned int)t >= mImage->GetVTKImages().size())
t = mImage->GetVTKImages().size() -1;
- if (mCurrentTSlice == t) return;
-
mCurrentTSlice = t;
mImageReslice->SetInput( mImage->GetVTKImages()[mCurrentTSlice] );
if (mVF && mVFActor->GetVisibility()) {
// of the displayed image in the slicing direction.
void vvSlicer::AdjustResliceToSliceOrientation(vtkImageReslice *reslice)
{
- // Reset autocrop
- double origin[3] = {VTK_DOUBLE_MAX, VTK_DOUBLE_MAX, VTK_DOUBLE_MAX};
- double spacing[3] = {VTK_DOUBLE_MAX, VTK_DOUBLE_MAX, VTK_DOUBLE_MAX};
- reslice->SetOutputOrigin(origin);
- reslice->SetOutputSpacing(spacing);
+ // Reset autocrop and update output information
+ reslice->SetOutputOriginToDefault();
+ reslice->SetOutputSpacingToDefault();
reslice->GetOutput()->UpdateInformation();
+
+ // Ge new origin / spacing
+ double origin[3];
+ double spacing[3];
reslice->GetOutput()->GetOrigin(origin);
reslice->GetOutput()->GetSpacing(spacing);
reslice->SetOutputOrigin(origin);
reslice->SetOutputSpacing(spacing);
reslice->UpdateInformation();
+ reslice->GetOutput()->UpdateInformation();
}
//------------------------------------------------------------------------------
// Local copy of extent
int w_ext[6];
- copyExtent(GetExtent(), w_ext);
+ int* ext = GetExtent();
+ copyExtent(ext, w_ext);
// Set slice value
- w_ext[ this->SliceOrientation*2 ] = this->Slice;
- w_ext[ this->SliceOrientation*2+1 ] = this->Slice;
+ int s = this->Slice > ext[this->SliceOrientation*2+1] ? ext[this->SliceOrientation*2 + 1] : this->Slice;
+ w_ext[ this->SliceOrientation*2 ] = s;
+ w_ext[ this->SliceOrientation*2+1 ] = s;
// Image actor
this->ImageActor->SetDisplayExtent(w_ext);
// Overlay image actor
if (mOverlay && mOverlayActor->GetVisibility()) {
+ AdjustResliceToSliceOrientation(mOverlayReslice);
int overExtent[6];
- mOverlayReslice->GetOutput()->UpdateInformation();
this->ConvertImageToImageDisplayExtent(input, w_ext, mOverlayReslice->GetOutput(), overExtent);
ClipDisplayedExtent(overExtent, mOverlayMapper->GetInput()->GetWholeExtent());
mOverlayActor->SetDisplayExtent( overExtent );
// Fusion image actor
if (mFusion && mFusionActor->GetVisibility()) {
+ AdjustResliceToSliceOrientation(mFusionReslice);
int fusExtent[6];
- mFusionReslice->GetOutput()->UpdateInformation();
this->ConvertImageToImageDisplayExtent(input, w_ext, mFusionReslice->GetOutput(), fusExtent);
ClipDisplayedExtent(fusExtent, mFusionMapper->GetInput()->GetWholeExtent());
mFusionActor->SetDisplayExtent(fusExtent);
dExtents[i] = (dExtents[i]- targetImage->GetOrigin()[i/2]) / targetImage->GetSpacing()[i/2];
// Round to nearest
- targetExtent[i] = itk::Math::Round<double>(dExtents[i]);
+ //targetExtent[i] = itk::Math::Round<double>(dExtents[i]);
+ targetExtent[i] = itk::Math::Floor<double>(dExtents[i]);
}
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::SetDisplayMode(bool i)
{
- this->GetImageActor()->SetVisibility(i);
- this->GetAnnotation()->SetVisibility(i);
this->GetRenderer()->SetDraw(i);
- if (mLandActor)
- mLandActor->SetVisibility(i);
- pdmA->SetVisibility(i);
if (i)
UpdateDisplayExtent();
}
vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
if (cam) {
double *position = cam->GetPosition();
- switch (this->SliceOrientation) {
+ double factor[3] = {1, 1, 1};
+ factor[this->SliceOrientation] = -1;
+ cam->SetPosition(factor[0]*position[0],factor[1]*position[1],factor[2]*position[2]);
+
+/* switch (this->SliceOrientation) {
case vtkImageViewer2::SLICE_ORIENTATION_XY:
cam->SetPosition(position[0],position[1],-position[2]);
break;
case vtkImageViewer2::SLICE_ORIENTATION_YZ:
cam->SetPosition(-position[0],position[1],position[2]);
break;
- }
+ }*/
+
this->Renderer->ResetCameraClippingRange();
this->UpdateDisplayExtent();
}
vtkLookupTable* LUT = static_cast<vtkLookupTable*>(this->GetWindowLevel()->GetLookupTable());
if ( LUT ) {
double level = this->GetWindowLevel()->GetLevel();
- LUT->SetTableRange(level-fabs(window)/4,level+fabs(window)/4);
+ LUT->SetTableRange(level-fabs(window)/2,level+fabs(window)/2);
LUT->Build();
}
this->vtkImageViewer2::SetColorWindow(window);
}
//----------------------------------------------------------------------------
-
//----------------------------------------------------------------------------
void vvSlicer::SetColorLevel(double level)
{
vtkLookupTable* LUT = static_cast<vtkLookupTable*>(this->GetWindowLevel()->GetLookupTable());
if ( LUT ) {
double window = this->GetWindowLevel()->GetWindow();
- LUT->SetTableRange(level-fabs(window)/4,level+fabs(window)/4);
+ LUT->SetTableRange(level-fabs(window)/2,level+fabs(window)/2);
LUT->Build();
}
this->vtkImageViewer2::SetColorLevel(level);
}
//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+double vvSlicer::GetOverlayColorWindow()
+{
+ if(mOverlayMapper)
+ return mOverlayMapper->GetWindow();
+ else
+ return 0.;
+}
+//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+double vvSlicer::GetOverlayColorLevel()
+{
+ if(mOverlayMapper)
+ return mOverlayMapper->GetLevel();
+ else
+ return 0.;
+}
+//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+void vvSlicer::SetOverlayColorWindow(double window)
+{
+ mOverlayMapper->SetWindow(window);
+}
+//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+void vvSlicer::SetOverlayColorLevel(double level)
+{
+ mOverlayMapper->SetLevel(level);
+}
+//----------------------------------------------------------------------------
+
//----------------------------------------------------------------------------
// Returns the min an the max value in a 41x41 region around the mouse pointer
-void vvSlicer::GetExtremasAroundMousePointer(double & min, double & max)
+void vvSlicer::GetExtremasAroundMousePointer(double & min, double & max, vtkImageData *image, vtkTransform *transform)
{
//Get mouse pointer position in view coordinates
- double fLocalExtents[6];
+ double corner1[3];
+ double corner2[3];
for(int i=0; i<3; i++) {
- fLocalExtents[i*2 ] = mCurrent[i];
- fLocalExtents[i*2+1] = mCurrent[i];
+ corner1[i] = mCurrent[i];
+ corner2[i] = mCurrent[i];
}
- this->Renderer->WorldToView(fLocalExtents[0], fLocalExtents[2], fLocalExtents[4]);
- this->Renderer->WorldToView(fLocalExtents[1], fLocalExtents[3], fLocalExtents[5]);
- for(int i=0; i<3; i++) {
- if (i!=SliceOrientation) { //SR: assumes that SliceOrientation is valid in ViewCoordinates (???)
- fLocalExtents[i*2 ] -= 0.2;
- fLocalExtents[i*2+1] += 0.2;
- }
- }
- this->Renderer->ViewToWorld(fLocalExtents[0], fLocalExtents[2], fLocalExtents[4]);
- this->Renderer->ViewToWorld(fLocalExtents[1], fLocalExtents[3], fLocalExtents[5]);
+
+ this->Renderer->WorldToView(corner1[0], corner1[1], corner1[2]);
+ this->Renderer->WorldToView(corner2[0], corner2[1], corner2[2]);
+
+ // In view coordinates, x is the slicer width and y is the slicer height are the in-plane axis
+ int w, h;
+ this->Renderer->GetTiledSize(&w, &h);
+ corner1[0] -= 0.2*h/(double)w;
+ corner2[0] += 0.2*h/(double)w;
+ corner1[1] -= 0.2;
+ corner2[1] += 0.2;
+ this->Renderer->ViewToWorld(corner1[0], corner1[1], corner1[2]);
+ this->Renderer->ViewToWorld(corner2[0], corner2[1], corner2[2]);
//Convert to image pixel coordinates (rounded)
+ transform->TransformPoint(corner1, corner1);
+ transform->TransformPoint(corner2, corner2);
int iLocalExtents[6];
for(int i=0; i<3; i++) {
- fLocalExtents[i*2 ] = (fLocalExtents[i*2 ] - this->GetInput()->GetOrigin()[i])/this->GetInput()->GetSpacing()[i];
- fLocalExtents[i*2+1] = (fLocalExtents[i*2+1] - this->GetInput()->GetOrigin()[i])/this->GetInput()->GetSpacing()[i];
+ corner1[i] = (corner1[i] - image->GetOrigin()[i])/image->GetSpacing()[i];
+ corner2[i] = (corner2[i] - image->GetOrigin()[i])/image->GetSpacing()[i];
- iLocalExtents[i*2 ] = lrint(fLocalExtents[i*2 ]);
- iLocalExtents[i*2+1] = lrint(fLocalExtents[i*2+1]);
+ iLocalExtents[i*2 ] = lrint(corner1[i]);
+ iLocalExtents[i*2+1] = lrint(corner2[i]);
if(iLocalExtents[i*2 ]>iLocalExtents[i*2+1])
std::swap(iLocalExtents[i*2], iLocalExtents[i*2+1]);
}
vtkSmartPointer<vtkExtractVOI> voiFilter = vtkSmartPointer<vtkExtractVOI>::New();
- voiFilter->SetInput(this->GetInput());
+ voiFilter->SetInput(image);
voiFilter->SetVOI(iLocalExtents);
voiFilter->Update();
if (!voiFilter->GetOutput()->GetNumberOfPoints()) {
//----------------------------------------------------------------------------
void vvSlicer::Render()
{
- if (this->GetWindowLevel()->GetLookupTable() && !this->mOverlay && !this->mFusion) {
+ if (this->mFusion && mFusionActor->GetVisibility() && showFusionLegend) {
+ legend->SetLookupTable(this->GetFusionMapper()->GetLookupTable());
+ legend->UseOpacityOn();
+ legend->SetVisibility(1);
+ }
+ else if (this->GetWindowLevel()->GetLookupTable() && !this->mOverlay) {
legend->SetLookupTable(this->GetWindowLevel()->GetLookupTable());
+ legend->UseOpacityOff();
legend->SetVisibility(1);
} else legend->SetVisibility(0);
int ix, iy, iz;
double value = this->GetScalarComponentAsDouble(this->GetInput(), X, Y, Z, ix, iy, iz);
- worldPos << "data value : " << value << std::endl;
+ if(ImageActor->GetVisibility())
+ worldPos << "data value : " << value << std::endl;
+
worldPos << "mm : " << lrint(mCurrent[0]) << ' '
<< lrint(mCurrent[1]) << ' '
<< lrint(mCurrent[2]) << ' '
if (mOverlay && mOverlayActor->GetVisibility()) {
- mOverlayMapper->SetWindow(this->GetColorWindow());
- mOverlayMapper->SetLevel(this->GetColorLevel());
+ if(mLinkOverlayWindowLevel) {
+ mOverlayMapper->SetWindow(this->GetColorWindow());
+ mOverlayMapper->SetLevel(this->GetColorLevel());
+ }
mOverlayMapper->GetOutput()->SetUpdateExtent(mOverlayActor->GetDisplayExtent());
mOverlayMapper->GetOutput()->Update();
mOverlayMapper->Update();
//----------------------------------------------------------------------------
void vvSlicer::UpdateCursorPosition()
{
- if (this->GetImageActor()->GetVisibility()) {
- pdmA->SetVisibility(true);
- mCursor[0] = mCurrent[0];
- mCursor[1] = mCurrent[1];
- mCursor[2] = mCurrent[2];
- mCursor[3] = mCurrentTSlice;
- }
+ pdmA->SetVisibility(true);
+ mCursor[0] = mCurrent[0];
+ mCursor[1] = mCurrent[1];
+ mCursor[2] = mCurrent[2];
+ mCursor[3] = mCurrentTSlice;
}
//----------------------------------------------------------------------------