You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
639 lines
19 KiB
C++
639 lines
19 KiB
C++
/*=========================================================================
|
|
|
|
Program: Visualization Toolkit
|
|
Module: vtkResliceCursorLineRepresentation.cxx
|
|
|
|
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
|
|
All rights reserved.
|
|
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even
|
|
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
PURPOSE. See the above copyright notice for more information.
|
|
|
|
=========================================================================*/
|
|
#include "vtkResliceCursorLineRepresentation.h"
|
|
#include "vtkHandleRepresentation.h"
|
|
#include "vtkCoordinate.h"
|
|
#include "vtkRenderer.h"
|
|
#include "vtkImageData.h"
|
|
#include "vtkMath.h"
|
|
#include "vtkLine.h"
|
|
#include "vtkTextProperty.h"
|
|
#include "vtkWindow.h"
|
|
#include "vtkResliceCursorPicker.h"
|
|
#include "vtkPlaneSource.h"
|
|
#include "vtkPoints.h"
|
|
#include "vtkPolyData.h"
|
|
#include "vtkCamera.h"
|
|
#include "vtkPlane.h"
|
|
#include "vtkPolyDataMapper2D.h"
|
|
#include "vtkActor2D.h"
|
|
#include "vtkTextMapper.h"
|
|
#include "vtkTextProperty.h"
|
|
#include "vtkProperty2D.h"
|
|
#include "vtkPointHandleRepresentation2D.h"
|
|
#include "vtkObjectFactory.h"
|
|
#include "vtkInteractorObserver.h"
|
|
#include "vtkResliceCursorActor.h"
|
|
#include "vtkResliceCursorPolyDataAlgorithm.h"
|
|
#include "vtkResliceCursor.h"
|
|
#include "vtkBoundingBox.h"
|
|
#include "vtkMatrix4x4.h"
|
|
#include "vtkImageActor.h"
|
|
#include "vtkTextActor.h"
|
|
#include "vtkImageReslice.h"
|
|
#include "vtkSmartPointer.h"
|
|
|
|
#include <sstream>
|
|
|
|
vtkStandardNewMacro(vtkResliceCursorLineRepresentation);
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
vtkResliceCursorLineRepresentation::vtkResliceCursorLineRepresentation()
|
|
{
|
|
this->ResliceCursorActor = vtkResliceCursorActor::New();
|
|
|
|
this->Picker = vtkResliceCursorPicker::New();
|
|
this->Picker->SetTolerance(0.025);
|
|
|
|
this->MatrixReslice = vtkMatrix4x4::New();
|
|
this->MatrixView = vtkMatrix4x4::New();
|
|
this->MatrixReslicedView = vtkMatrix4x4::New();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
vtkResliceCursorLineRepresentation::~vtkResliceCursorLineRepresentation()
|
|
{
|
|
this->ResliceCursorActor->Delete();
|
|
this->Picker->Delete();
|
|
this->MatrixReslice->Delete();
|
|
this->MatrixView->Delete();
|
|
this->MatrixReslicedView->Delete();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
vtkResliceCursor * vtkResliceCursorLineRepresentation::GetResliceCursor()
|
|
{
|
|
return this->ResliceCursorActor->GetCursorAlgorithm()->GetResliceCursor();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
int vtkResliceCursorLineRepresentation::
|
|
ComputeInteractionState(int X, int Y, int modify)
|
|
{
|
|
this->InteractionState = vtkResliceCursorLineRepresentation::Outside;
|
|
|
|
if (!this->Renderer)
|
|
{
|
|
return this->InteractionState;
|
|
}
|
|
|
|
vtkResliceCursor * rc = this->GetResliceCursor();
|
|
if (!rc)
|
|
{
|
|
vtkErrorMacro( << "Reslice cursor not set!" );
|
|
return this->InteractionState;
|
|
}
|
|
|
|
this->Modifier = modify;
|
|
|
|
|
|
// Ensure that the axis is initialized..
|
|
const int axis1 = this->ResliceCursorActor->GetCursorAlgorithm()->GetAxis1();
|
|
double bounds[6];
|
|
this->ResliceCursorActor->GetCenterlineActor(axis1)->GetBounds(bounds);
|
|
if (bounds[1] < bounds[0])
|
|
{
|
|
return this->InteractionState;
|
|
}
|
|
|
|
// Pick
|
|
this->Picker->SetResliceCursorAlgorithm(
|
|
this->ResliceCursorActor->GetCursorAlgorithm() );
|
|
int picked = this->Picker->Pick(X, Y, 0, this->Renderer );
|
|
|
|
const bool pickedAxis1 = this->Picker->GetPickedAxis1() ? true : false;
|
|
const bool pickedAxis2 = this->Picker->GetPickedAxis2() ? true : false;
|
|
const bool pickedCenter = this->Picker->GetPickedCenter() ? true : false;
|
|
if (picked)
|
|
{
|
|
this->Picker->GetPickPosition(this->StartPickPosition);
|
|
}
|
|
|
|
// Now assign the interaction state
|
|
|
|
if (pickedCenter)
|
|
{
|
|
this->InteractionState = vtkResliceCursorLineRepresentation::OnCenter;
|
|
}
|
|
else if (pickedAxis1)
|
|
{
|
|
this->InteractionState = vtkResliceCursorLineRepresentation::OnAxis1;
|
|
}
|
|
else if (pickedAxis2)
|
|
{
|
|
this->InteractionState = vtkResliceCursorLineRepresentation::OnAxis2;
|
|
}
|
|
|
|
return this->InteractionState;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Record the current event position, and the center position.
|
|
void vtkResliceCursorLineRepresentation
|
|
::StartWidgetInteraction(double startEventPos[2])
|
|
{
|
|
this->StartEventPosition[0] = startEventPos[0];
|
|
this->StartEventPosition[1] = startEventPos[1];
|
|
|
|
if (this->ManipulationMode == WindowLevelling)
|
|
{
|
|
this->InitialWindow = this->CurrentWindow;
|
|
this->InitialLevel = this->CurrentLevel;
|
|
}
|
|
else
|
|
{
|
|
if ( vtkResliceCursor *rc = this->GetResliceCursor() )
|
|
{
|
|
rc->GetCenter(this->StartCenterPosition);
|
|
}
|
|
}
|
|
|
|
this->LastEventPosition[0] = startEventPos[0];
|
|
this->LastEventPosition[1] = startEventPos[1];
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void vtkResliceCursorLineRepresentation::WidgetInteraction(double e[2])
|
|
{
|
|
vtkResliceCursor *rc = this->GetResliceCursor();
|
|
|
|
if (this->ManipulationMode == WindowLevelling)
|
|
{
|
|
this->WindowLevel(e[0], e[1]);
|
|
this->LastEventPosition[0] = e[0];
|
|
this->LastEventPosition[1] = e[1];
|
|
return;
|
|
}
|
|
|
|
// Depending on the state, different motions are allowed.
|
|
|
|
if ( this->InteractionState == Outside || ! this->Renderer || !rc )
|
|
{
|
|
this->LastEventPosition[0] = e[0];
|
|
this->LastEventPosition[1] = e[1];
|
|
return;
|
|
}
|
|
|
|
|
|
if (rc->GetThickMode() &&
|
|
this->ManipulationMode ==
|
|
vtkResliceCursorRepresentation::ResizeThickness)
|
|
{
|
|
|
|
double sf = 1.0;
|
|
|
|
// Compute the scale factor
|
|
int *size = this->Renderer->GetSize();
|
|
double dPos = e[1]-this->LastEventPosition[1];
|
|
sf *= (1.0 + 2.0*(dPos / size[1])); //scale factor of 2.0 is arbitrary
|
|
|
|
double thickness[3];
|
|
rc->GetThickness(thickness);
|
|
rc->SetThickness( thickness[0] * sf,
|
|
thickness[1] * sf,
|
|
thickness[2] * sf );
|
|
|
|
this->LastEventPosition[0] = e[0];
|
|
this->LastEventPosition[1] = e[1];
|
|
|
|
return;
|
|
}
|
|
|
|
// depending on the state, perform different operations
|
|
//
|
|
// 1. Translation
|
|
|
|
if ( this->InteractionState == OnCenter && !this->Modifier )
|
|
{
|
|
|
|
// Intersect with the viewing vector. We will use this point and the
|
|
// start event point to compute an offset vector to translate the
|
|
// center by.
|
|
|
|
double intersectionPos[3], newCenter[3];
|
|
this->Picker->Pick( e, intersectionPos, this->Renderer );
|
|
|
|
// Offset the center by this vector.
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
newCenter[i] = this->StartCenterPosition[i] +
|
|
intersectionPos[i] - this->StartPickPosition[i];
|
|
}
|
|
|
|
rc->SetCenter(newCenter);
|
|
}
|
|
|
|
|
|
// 2. Rotation of axis 1
|
|
|
|
if ( this->InteractionState == OnAxis1 && !this->Modifier )
|
|
{
|
|
this->RotateAxis( e,
|
|
this->ResliceCursorActor->GetCursorAlgorithm()->GetPlaneAxis1() );
|
|
}
|
|
|
|
// 3. Rotation of axis 2
|
|
|
|
if ( this->InteractionState == OnAxis2 && !this->Modifier )
|
|
{
|
|
this->RotateAxis( e,
|
|
this->ResliceCursorActor->GetCursorAlgorithm()->GetPlaneAxis2() );
|
|
}
|
|
|
|
// 4. Rotation of both axes
|
|
|
|
if ( (this->InteractionState == OnAxis2 ||
|
|
this->InteractionState == OnAxis1) && this->Modifier )
|
|
{
|
|
// Rotate both by the same angle
|
|
const double angle = this->RotateAxis( e,
|
|
this->ResliceCursorActor->GetCursorAlgorithm()->GetPlaneAxis1() );
|
|
this->RotateAxis(
|
|
this->ResliceCursorActor->GetCursorAlgorithm()->GetPlaneAxis2(), angle );
|
|
}
|
|
|
|
this->LastEventPosition[0] = e[0];
|
|
this->LastEventPosition[1] = e[1];
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
double vtkResliceCursorLineRepresentation
|
|
::RotateAxis( double e[2], int axis )
|
|
{
|
|
vtkResliceCursor *rc = this->GetResliceCursor();
|
|
|
|
double center[3];
|
|
rc->GetCenter(center);
|
|
|
|
// Intersect with the viewing vector. We will use this point and the
|
|
// start event point to compute the rotation angle
|
|
|
|
double currIntersectionPos[3], lastIntersectionPos[3];
|
|
this->DisplayToReslicePlaneIntersection( e, currIntersectionPos );
|
|
this->DisplayToReslicePlaneIntersection(
|
|
this->LastEventPosition, lastIntersectionPos );
|
|
|
|
if (lastIntersectionPos[0] == currIntersectionPos[0] &&
|
|
lastIntersectionPos[1] == currIntersectionPos[1] &&
|
|
lastIntersectionPos[2] == currIntersectionPos[2])
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
double lastVector[3], currVector[3];
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
lastVector[i] = lastIntersectionPos[i] - center[i];
|
|
currVector[i] = currIntersectionPos[i] - center[i];
|
|
}
|
|
|
|
vtkMath::Normalize(lastVector);
|
|
vtkMath::Normalize(currVector);
|
|
|
|
// compute the angle betweem both vectors. This is the amount to
|
|
// rotate by.
|
|
double angle = acos(vtkMath::Dot(lastVector, currVector));
|
|
double crossVector[3];
|
|
vtkMath::Cross(lastVector, currVector, crossVector);
|
|
|
|
double aboutAxis[3];
|
|
const int rcPlaneIdx = this->ResliceCursorActor->
|
|
GetCursorAlgorithm()->GetReslicePlaneNormal();
|
|
vtkPlane *normalPlane = rc->GetPlane(rcPlaneIdx);
|
|
normalPlane->GetNormal(aboutAxis);
|
|
const double align = vtkMath::Dot(aboutAxis, crossVector);
|
|
const double sign = align > 0 ? 1.0 : -1.0;
|
|
angle *= sign;
|
|
|
|
if (angle == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
this->RotateAxis( axis, angle );
|
|
|
|
return angle;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Get the plane normal to the viewing axis.
|
|
vtkResliceCursorPolyDataAlgorithm *
|
|
vtkResliceCursorLineRepresentation::GetCursorAlgorithm()
|
|
{
|
|
return this->ResliceCursorActor->GetCursorAlgorithm();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void vtkResliceCursorLineRepresentation
|
|
::RotateAxis( int axis, double angle )
|
|
{
|
|
vtkResliceCursor * rc = this->GetResliceCursor();
|
|
vtkPlane * planeToBeRotated = rc->GetPlane(axis);
|
|
|
|
const int rcPlaneIdx = this->ResliceCursorActor->
|
|
GetCursorAlgorithm()->GetReslicePlaneNormal();
|
|
|
|
vtkPlane *normalPlane = rc->GetPlane(rcPlaneIdx);
|
|
|
|
double vectorToBeRotated[3], aboutAxis[3], rotatedVector[3];
|
|
planeToBeRotated->GetNormal(vectorToBeRotated);
|
|
normalPlane->GetNormal(aboutAxis);
|
|
|
|
this->RotateVectorAboutVector( vectorToBeRotated,
|
|
aboutAxis, angle, rotatedVector );
|
|
planeToBeRotated->SetNormal(rotatedVector);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void vtkResliceCursorLineRepresentation
|
|
::RotateVectorAboutVector( double vectorToBeRotated[3],
|
|
double axis[3], // vector about which we rotate
|
|
double angle, // angle in radians
|
|
double o[3] )
|
|
{
|
|
// let
|
|
// [v] = [vx, vy, vz] the vector to be rotated.
|
|
// [l] = [lx, ly, lz] the vector about rotation
|
|
// | 1 0 0|
|
|
// [i] = | 0 1 0| the identity matrix
|
|
// | 0 0 1|
|
|
//
|
|
// | 0 lz -ly |
|
|
// [L] = | -lz 0 lx |
|
|
// | ly -lx 0 |
|
|
//
|
|
// d = sqrt(lx*lx + ly*ly + lz*lz)
|
|
// a the angle of rotation
|
|
//
|
|
// then
|
|
//
|
|
// matrix operations gives:
|
|
//
|
|
// [v] = [v]x{[i] + sin(a)/d*[L] + ((1 - cos(a))/(d*d)*([L]x[L]))}
|
|
|
|
// normalize the axis vector
|
|
double v[3] = { vectorToBeRotated[0],
|
|
vectorToBeRotated[1], vectorToBeRotated[2] };
|
|
double l[3] = { axis[0], axis[1], axis[2] };
|
|
vtkMath::Normalize(v);
|
|
vtkMath::Normalize(l);
|
|
const double u = sin(angle);
|
|
const double w = 1.0 - cos(angle);
|
|
|
|
o[0] = v[0] * (1 - w * (l[2]*l[2] + l[1]*l[1])) +
|
|
v[1] * (-u * l[2] + w * l[0] * l[1]) +
|
|
v[2] * (u * l[1] + w * l[0] * l[1]);
|
|
o[1] = v[0] * (u * l[2] + w * l[0] * l[1]) +
|
|
v[1] * (1 - w * (l[0]*l[0] + l[2]*l[2])) +
|
|
v[2] * (-u * l[0] + w * l[1] * l[2] );
|
|
o[2] = v[0] * (-u * l[1] + w * l[0] * l[2]) +
|
|
v[1] * (u * l[0] + w * l[1] * l[2]) +
|
|
v[2] * (1 - w * (l[1]*l[1] + l[0]*l[0]));
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
int vtkResliceCursorLineRepresentation
|
|
::DisplayToReslicePlaneIntersection(
|
|
double displayPos[2], double intersectionPos[3] )
|
|
{
|
|
// First compute the equivalent of this display point on the focal plane
|
|
double fp[4], tmp1[4], camPos[4], eventFPpos[4];
|
|
this->Renderer->GetActiveCamera()->GetFocalPoint(fp);
|
|
this->Renderer->GetActiveCamera()->GetPosition(camPos);
|
|
fp[3] = 1.0;
|
|
this->Renderer->SetWorldPoint(fp);
|
|
this->Renderer->WorldToDisplay();
|
|
this->Renderer->GetDisplayPoint(tmp1);
|
|
|
|
tmp1[0] = displayPos[0];
|
|
tmp1[1] = displayPos[1];
|
|
this->Renderer->SetDisplayPoint(tmp1);
|
|
this->Renderer->DisplayToWorld();
|
|
this->Renderer->GetWorldPoint(eventFPpos);
|
|
|
|
const int rcPlaneIdx = this->ResliceCursorActor->
|
|
GetCursorAlgorithm()->GetReslicePlaneNormal();
|
|
vtkPlane *normalPlane = this->GetResliceCursor()->GetPlane(rcPlaneIdx);
|
|
|
|
double t;
|
|
|
|
return normalPlane->IntersectWithLine(eventFPpos, camPos, t, intersectionPos);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void vtkResliceCursorLineRepresentation::BuildRepresentation()
|
|
{
|
|
if ( this->GetMTime() > this->BuildTime ||
|
|
this->GetResliceCursor()->GetMTime() > this->BuildTime ||
|
|
(this->Renderer && this->Renderer->GetVTKWindow() &&
|
|
this->Renderer->GetVTKWindow()->GetMTime() > this->BuildTime) )
|
|
{
|
|
|
|
this->BuildTime.Modified();
|
|
}
|
|
|
|
this->Superclass::BuildRepresentation();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void vtkResliceCursorLineRepresentation::ReleaseGraphicsResources(vtkWindow *w)
|
|
{
|
|
this->ResliceCursorActor->ReleaseGraphicsResources(w);
|
|
this->TexturePlaneActor->ReleaseGraphicsResources(w);
|
|
this->ImageActor->ReleaseGraphicsResources(w);
|
|
this->TextActor->ReleaseGraphicsResources(w);
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
int vtkResliceCursorLineRepresentation::RenderOverlay(vtkViewport *viewport)
|
|
{
|
|
int count = 0;
|
|
|
|
if (this->TexturePlaneActor->GetVisibility() && !this->UseImageActor)
|
|
{
|
|
count += this->TexturePlaneActor->RenderOverlay(viewport);
|
|
}
|
|
if (this->ImageActor->GetVisibility() && this->UseImageActor)
|
|
{
|
|
count += this->ImageActor->RenderOverlay(viewport);
|
|
}
|
|
if (this->DisplayText && this->TextActor->GetVisibility())
|
|
{
|
|
count += this->TextActor->RenderOverlay(viewport);
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void vtkResliceCursorLineRepresentation::SetUserMatrix(vtkMatrix4x4 *m)
|
|
{
|
|
this->TexturePlaneActor->SetUserMatrix(m);
|
|
this->ResliceCursorActor->SetUserMatrix(m);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
int vtkResliceCursorLineRepresentation
|
|
::RenderOpaqueGeometry(vtkViewport *viewport)
|
|
{
|
|
this->BuildRepresentation();
|
|
|
|
const int normalAxis = this->ResliceCursorActor->
|
|
GetCursorAlgorithm()->GetReslicePlaneNormal();
|
|
|
|
// When the reslice plane is changed, update the camera to look at the
|
|
// normal to the reslice plane always.
|
|
|
|
double fp[3], cp[3], n[3];
|
|
this->Renderer->GetActiveCamera()->GetFocalPoint(fp);
|
|
this->Renderer->GetActiveCamera()->GetPosition(cp);
|
|
this->GetResliceCursor()->GetPlane(normalAxis)->GetNormal(n);
|
|
|
|
const double d = sqrt(vtkMath::Distance2BetweenPoints(cp,fp));
|
|
double newCamPos[3] = { fp[0] + (d * n[0]),
|
|
fp[1] + (d * n[1]),
|
|
fp[2] + (d * n[2]) };
|
|
this->Renderer->GetActiveCamera()->SetPosition(newCamPos);
|
|
|
|
// intersect with the plane to get updated focal point
|
|
double intersectionPos[3], t;
|
|
this->GetResliceCursor()->GetPlane(normalAxis)->
|
|
IntersectWithLine(fp, newCamPos, t, intersectionPos);
|
|
this->Renderer->GetActiveCamera()->SetFocalPoint(intersectionPos);
|
|
|
|
// Don't clip away any part of the data.
|
|
this->Renderer->ResetCameraClippingRange();
|
|
|
|
// Now Render all the actors.
|
|
|
|
int count = 0;
|
|
if (this->TexturePlaneActor->GetVisibility() && !this->UseImageActor)
|
|
{
|
|
count += this->TexturePlaneActor->RenderOpaqueGeometry(viewport);
|
|
}
|
|
if (this->ImageActor->GetVisibility() && this->UseImageActor)
|
|
{
|
|
count += this->ImageActor->RenderOpaqueGeometry(viewport);
|
|
}
|
|
count += this->ResliceCursorActor->RenderOpaqueGeometry(viewport);
|
|
if (this->DisplayText && this->TextActor->GetVisibility())
|
|
{
|
|
count += this->TextActor->RenderOpaqueGeometry(viewport);
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
// Get the bounds for this Actor as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax).
|
|
double *vtkResliceCursorLineRepresentation::GetBounds()
|
|
{
|
|
vtkMath::UninitializeBounds(this->InitialBounds);
|
|
|
|
if (vtkResliceCursor *r = this->GetResliceCursor())
|
|
{
|
|
r->GetImage()->GetBounds(this->InitialBounds);
|
|
}
|
|
|
|
//vtkBoundingBox *bb = new vtkBoundingBox();
|
|
//bb->AddBounds(this->ResliceCursorActor->GetBounds());
|
|
//bb->AddBounds(this->TexturePlaneActor->GetBounds());
|
|
//bb->GetBounds(bounds);
|
|
//delete bb;
|
|
|
|
return this->InitialBounds;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
int vtkResliceCursorLineRepresentation::RenderTranslucentPolygonalGeometry(
|
|
vtkViewport *viewport)
|
|
{
|
|
int count = 0;
|
|
if (this->TexturePlaneActor->GetVisibility() && !this->UseImageActor)
|
|
{
|
|
count +=
|
|
this->TexturePlaneActor->RenderTranslucentPolygonalGeometry(viewport);
|
|
}
|
|
|
|
if (this->ImageActor->GetVisibility() && this->UseImageActor)
|
|
{
|
|
count +=
|
|
this->ImageActor->RenderTranslucentPolygonalGeometry(viewport);
|
|
}
|
|
|
|
count += this->ResliceCursorActor->
|
|
RenderTranslucentPolygonalGeometry(viewport);
|
|
|
|
return count;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
int vtkResliceCursorLineRepresentation::HasTranslucentPolygonalGeometry()
|
|
{
|
|
return (this->ResliceCursorActor->HasTranslucentPolygonalGeometry() ||
|
|
(this->ImageActor->HasTranslucentPolygonalGeometry()
|
|
&& this->UseImageActor) ||
|
|
(this->TexturePlaneActor->HasTranslucentPolygonalGeometry()
|
|
&& !this->UseImageActor)) ? 1 : 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void vtkResliceCursorLineRepresentation::Highlight(int )
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void vtkResliceCursorLineRepresentation::PrintSelf(ostream& os, vtkIndent indent)
|
|
{
|
|
//Superclass typedef defined in vtkTypeMacro() found in vtkSetGet.h
|
|
this->Superclass::PrintSelf(os,indent);
|
|
|
|
os << indent << "ResliceCursorActor: " << this->ResliceCursorActor << "\n";
|
|
if (this->ResliceCursorActor)
|
|
{
|
|
this->ResliceCursorActor->PrintSelf(os, indent);
|
|
}
|
|
|
|
os << indent << "Picker: " << this->Picker << "\n";
|
|
if (this->Picker)
|
|
{
|
|
this->Picker->PrintSelf(os, indent);
|
|
}
|
|
|
|
os << indent << "MatrixReslicedView: " << this->MatrixReslicedView << "\n";
|
|
if (this->MatrixReslicedView)
|
|
{
|
|
this->MatrixReslicedView->PrintSelf(os, indent);
|
|
}
|
|
|
|
os << indent << "MatrixView: " << this->MatrixView << "\n";
|
|
if (this->MatrixView)
|
|
{
|
|
this->MatrixView->PrintSelf(os, indent);
|
|
}
|
|
|
|
os << indent << "MatrixReslice: " << this->MatrixReslice << "\n";
|
|
if (this->MatrixReslice)
|
|
{
|
|
this->MatrixReslice->PrintSelf(os, indent);
|
|
}
|
|
|
|
// this->StartPickPosition;
|
|
// this->StartCenterPosition;
|
|
}
|