CAxialFor3DView::CAxialFor3DView(void)
{
renWin= vtkRenderWindow::New();
ren = vtkRenderer::New();
interactor=vtkInteractorStyleImage::New();
iren=vtkRenderWindowInteractor::New();
ProgressCommand=vtkSmartPointer<vtkProgress>::New();
itkVTKExporter = VTKExportType::New();
VTKImporter = vtkImageImport::New();
itkVTKResampleExporter = VTKExportType::New();
VTKResampleImporter = vtkImageImport::New();
itk2vtk(itkVTKExporter,VTKImporter);
itk2vtk(itkVTKResampleExporter,VTKResampleImporter);
m_CommandObserver = CommandType::New();
m_CommandObserver->SetCallbackFunction( this, &CAxialFor3DView::ProgressUpdateFunc);
m_nProgress=0;
actorCount=0;
m_bCropImage=false;
}
void mitk::PlanesPerpendicularToLinesFilter::CreatePlane(const mitk::Point3D& curr)
{
int j;
for(j=0;j<3;++j)
normal[j] = last[j]-curr[j]; //@todo globally define normal direction of display xxx
normal.normalize();
down = vnl_cross_3d(normal, targetRight);
down.normalize();
right = vnl_cross_3d(down, normal);
right.normalize();
itk2vtk(last.GetVnlVector()-right*halfWidthInMM-down*halfHeightInMM, origin);
right *= targetSpacing[0];
down *= targetSpacing[1];
normal *= targetSpacing[2];
mitk::Matrix3D matrix;
matrix.GetVnlMatrix().set_column(0, right);
matrix.GetVnlMatrix().set_column(1, down);
matrix.GetVnlMatrix().set_column(2, normal);
PlaneGeometry::Pointer plane = PlaneGeometry::New();
plane->GetIndexToWorldTransform()->SetMatrix(matrix);
plane->SetOrigin(origin);
plane->SetBounds(bounds);
planes.push_back(plane);
last = curr;
}
bool mitk::ExtrudedContour::IsInside(const Point3D& worldPoint) const
{
static double polygonNormal[3]={0.0,0.0,1.0};
// project point onto plane
float xt[3];
itk2vtk(worldPoint, xt);
xt[0] = worldPoint[0]-m_Origin[0];
xt[1] = worldPoint[1]-m_Origin[1];
xt[2] = worldPoint[2]-m_Origin[2];
float dist=xt[0]*m_Normal[0]+xt[1]*m_Normal[1]+xt[2]*m_Normal[2];
xt[0] -= dist*m_Normal[0];
xt[1] -= dist*m_Normal[1];
xt[2] -= dist*m_Normal[2];
double x[3];
x[0] = xt[0]*m_Right[0]+xt[1]*m_Right[1]+xt[2]*m_Right[2];
x[1] = xt[0]*m_Down[0] +xt[1]*m_Down[1] +xt[2]*m_Down[2];
x[2] = 0;
// determine whether it's in the selection loop and then evaluate point
// in polygon only if absolutely necessary.
if ( x[0] >= this->m_ProjectedContourBounds[0] && x[0] <= this->m_ProjectedContourBounds[1] &&
x[1] >= this->m_ProjectedContourBounds[2] && x[1] <= this->m_ProjectedContourBounds[3] &&
this->m_Polygon->PointInPolygon(x, m_Polygon->Points->GetNumberOfPoints(),
((vtkDoubleArray *)this->m_Polygon->Points->GetData())->GetPointer(0),
(double*)const_cast<mitk::ExtrudedContour*>(this)->m_ProjectedContourBounds, polygonNormal) == 1 )
return true;
else
return false;
}
bool mitk::AffineInteractor::ExecuteAction(Action* action, mitk::StateEvent const* stateEvent)
{
bool ok = false;
TimeSlicedGeometry* inputtimegeometry = GetData()->GetTimeSlicedGeometry();
if (inputtimegeometry == NULL)
return false;
Geometry3D* geometry = inputtimegeometry->GetGeometry3D(m_TimeStep);
mitk::DisplayPositionEvent const *event = dynamic_cast <const mitk::DisplayPositionEvent *> (stateEvent->GetEvent());
switch (action->GetActionId())
{
case AcCHECKELEMENT:
{
mitk::Point3D worldPoint = event->GetWorldPosition();
/* now we have a worldpoint. check if it is inside our object and select/deselect it accordingly */
mitk::BoolProperty::Pointer selected;
mitk::ColorProperty::Pointer color;
std::auto_ptr<StateEvent> newStateEvent;
selected = dynamic_cast<mitk::BoolProperty*>(m_DataNode->GetProperty("selected"));
if ( selected.IsNull() ) {
selected = mitk::BoolProperty::New();
m_DataNode->GetPropertyList()->SetProperty("selected", selected);
}
color = dynamic_cast<mitk::ColorProperty*>(m_DataNode->GetProperty("color"));
if ( color.IsNull() ) {
color = mitk::ColorProperty::New();
m_DataNode->GetPropertyList()->SetProperty("color", color);
}
if (this->CheckSelected(worldPoint, m_TimeStep))
{
newStateEvent.reset(new mitk::StateEvent(EIDYES, stateEvent->GetEvent()));
selected->SetValue(true);
color->SetColor(1.0, 1.0, 0.0);
}
else
{
newStateEvent.reset(new mitk::StateEvent(EIDNO, stateEvent->GetEvent()));
selected = mitk::BoolProperty::New(false);
color->SetColor(0.0, 0.0, 1.0);
/*
mitk::BoundingObject* b = dynamic_cast<mitk::BoundingObject*>(m_DataNode->GetData());
if(b != NULL)
{
color = (b->GetPositive())? mitk::ColorProperty::New(0.0, 0.0, 1.0) : mitk::ColorProperty::New(1.0, 0.0, 0.0); // if deselected, a boundingobject is colored according to its positive/negative state
}
else
color = mitk::ColorProperty::New(1.0, 1.0, 1.0); // if deselcted and no bounding object, color is white
*/
}
/* write new state (selected/not selected) to the property */
this->HandleEvent( newStateEvent.get() );
ok = true;
break;
}
case AcADD:
{
mitk::Point3D worldPoint = event->GetWorldPosition();
std::auto_ptr<StateEvent> newStateEvent;
if (this->CheckSelected(worldPoint, m_TimeStep))
{
newStateEvent.reset(new mitk::StateEvent(EIDYES, event));
m_DataNode->GetPropertyList()->SetProperty("selected", mitk::BoolProperty::New(true)); // TODO: Generate an Select Operation and send it to the undo controller ?
}
else // if not selected, do nothing (don't deselect)
{
newStateEvent.reset(new mitk::StateEvent(EIDNO, event));
}
//call HandleEvent to leave the guard-state
this->HandleEvent( newStateEvent.get() );
ok = true;
break;
}
case AcTRANSLATESTART:
case AcROTATESTART:
case AcSCALESTART:
{
m_LastMousePosition = event->GetWorldPosition();
ok = true;
break;
}
case AcTRANSLATE:
{
mitk::Point3D newPosition;
newPosition = event->GetWorldPosition();
newPosition -= m_LastMousePosition.GetVectorFromOrigin(); // compute difference between actual and last mouse position
m_LastMousePosition = event->GetWorldPosition(); // save current mouse position as last position
/* create operation with position difference */
mitk::PointOperation* doOp = new mitk::PointOperation(OpMOVE, newPosition, 0); // Index is not used here
if (m_UndoEnabled) //write to UndoMechanism
{
mitk::Point3D oldPosition=geometry->GetCornerPoint(0);
PointOperation* undoOp = new mitk::PointOperation(OpMOVE, oldPosition, 0);
OperationEvent *operationEvent = new OperationEvent(geometry, doOp, undoOp);
m_UndoController->SetOperationEvent(operationEvent);
}
/* execute the Operation */
geometry->ExecuteOperation(doOp);
if (!m_UndoEnabled)
delete doOp;
ok = true;
break;
}
case AcTRANSLATEEND:
{
m_UndoController->SetOperationEvent(new UndoStackItem("Move object"));
m_DataNode->InvokeEvent(TranslateEvent());
break;
}
case AcROTATE:
{
mitk::Point3D p = event->GetWorldPosition();
mitk::Vector3D newPosition = p.GetVectorFromOrigin();
mitk::Point3D dataPosition = geometry->GetCenter();
newPosition = newPosition - dataPosition.GetVectorFromOrigin(); // calculate vector from center of the data object to the current mouse position
mitk::Vector3D startPosition = m_LastMousePosition.GetVectorFromOrigin() - dataPosition.GetVectorFromOrigin(); // calculate vector from center of the data object to the last mouse position
/* calculate rotation axis (by calculating the cross produkt of the vectors) */
mitk::Vector3D rotationaxis;
rotationaxis[0] = startPosition[1] * newPosition[2] - startPosition[2] * newPosition[1];
rotationaxis[1] = startPosition[2] * newPosition[0] - startPosition[0] * newPosition[2];
rotationaxis[2] = startPosition[0] * newPosition[1] - startPosition[1] * newPosition[0];
/* calculate rotation angle in degrees */
mitk::ScalarType angle = atan2((mitk::ScalarType)rotationaxis.GetNorm(), (mitk::ScalarType) (newPosition * startPosition)) * (180/vnl_math::pi);
m_LastMousePosition = p; // save current mouse position as last mouse position
/* create operation with center of rotation, angle and axis and send it to the geometry and Undo controller */
mitk::RotationOperation* doOp = new mitk::RotationOperation(OpROTATE, dataPosition, rotationaxis, angle);
if (m_UndoEnabled) //write to UndoMechanism
{
RotationOperation* undoOp = new mitk::RotationOperation(OpROTATE, dataPosition, rotationaxis, -angle);
OperationEvent *operationEvent = new OperationEvent(geometry, doOp, undoOp);
m_UndoController->SetOperationEvent(operationEvent);
}
/* execute the Operation */
geometry->ExecuteOperation(doOp);
if(!m_UndoEnabled)
delete doOp;
ok = true;
break;
}
case AcROTATEEND:
{
m_UndoController->SetOperationEvent(new UndoStackItem("Rotate object"));
m_DataNode->InvokeEvent(RotateEvent());
break;
}
case AcSCALE:
{
mitk::Point3D p = event->GetWorldPosition();
mitk::Vector3D v = p - m_LastMousePosition;
/* calculate scale changes */
mitk::Point3D newScale;
newScale[0] = (geometry->GetAxisVector(0) * v) / geometry->GetExtentInMM(0); // Scalarprodukt of normalized Axis
newScale[1] = (geometry->GetAxisVector(1) * v) / geometry->GetExtentInMM(1); // and direction vector of mouse movement
newScale[2] = (geometry->GetAxisVector(2) * v) / geometry->GetExtentInMM(2); // is the length of the movement vectors
// projection onto the axis
/* convert movement to local object coordinate system and mirror it to the positive quadrant */
Vector3D start;
Vector3D end;
mitk::ScalarType convert[3];
itk2vtk(m_LastMousePosition, convert);
geometry->GetVtkTransform()->GetInverse()->TransformPoint(convert, convert); // transform start point to local object coordinates
start[0] = fabs(convert[0]); start[1] = fabs(convert[1]); start[2] = fabs(convert[2]); // mirror it to the positive quadrant
itk2vtk(p, convert);
geometry->GetVtkTransform()->GetInverse()->TransformPoint(convert, convert); // transform end point to local object coordinates
end[0] = fabs(convert[0]); end[1] = fabs(convert[1]); end[2] = fabs(convert[2]); // mirror it to the positive quadrant
/* check if mouse movement is towards or away from the objects axes and adjust scale factors accordingly */
Vector3D vLocal = start - end;
newScale[0] = (vLocal[0] > 0.0) ? -fabs(newScale[0]) : +fabs(newScale[0]);
newScale[1] = (vLocal[1] > 0.0) ? -fabs(newScale[1]) : +fabs(newScale[1]);
newScale[2] = (vLocal[2] > 0.0) ? -fabs(newScale[2]) : +fabs(newScale[2]);
m_LastMousePosition = p; // update lastPosition for next mouse move
/* generate Operation and send it to the receiving geometry */
PointOperation* doOp = new mitk::PointOperation(OpSCALE, newScale, 0); // Index is not used here
if (m_UndoEnabled) //write to UndoMechanism
{
mitk::Point3D oldScaleData;
oldScaleData[0] = -newScale[0];
oldScaleData[1] = -newScale[1];
oldScaleData[2] = -newScale[2];
PointOperation* undoOp = new mitk::PointOperation(OpSCALE, oldScaleData, 0);
OperationEvent *operationEvent = new OperationEvent(geometry, doOp, undoOp);
m_UndoController->SetOperationEvent(operationEvent);
}
/* execute the Operation */
geometry->ExecuteOperation(doOp);
if(!m_UndoEnabled)
delete doOp;
/* Update Volume Property with new value */
/*
mitk::BoundingObject* b = dynamic_cast<mitk::BoundingObject*>(m_DataNode->GetData());
if (b != NULL)
{
m_DataNode->GetPropertyList()->SetProperty("volume", FloatProperty::New(b->GetVolume()));
//MITK_INFO << "Volume of Boundingobject is " << b->GetVolume()/1000.0 << " ml" << std::endl;
}
*/
ok = true;
break;
}
case AcSCALEEND:
{
m_UndoController->SetOperationEvent(new UndoStackItem("Scale object"));
m_DataNode->InvokeEvent(ScaleEvent());
break;
}
default:
ok = Superclass::ExecuteAction(action, stateEvent);//, objectEventId, groupEventId);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return ok;
}
void mitk::AutoCropImageFilter::GenerateOutputInformation()
{
mitk::Image::Pointer input = const_cast<mitk::Image*> (this->GetInput());
mitk::Image::Pointer output = this->GetOutput();
if(input->GetDimension() <= 2)
{
MITK_ERROR << "Only 3D any 4D images are supported." << std::endl;
return;
}
ComputeNewImageBounds();
if ((output->IsInitialized()) && (output->GetPipelineMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
return;
itkDebugMacro(<<"GenerateOutputInformation()");
// PART I: initialize input requested region. We do this already here (and not
// later when GenerateInputRequestedRegion() is called), because we
// also need the information to setup the output.
// pre-initialize input-requested-region to largest-possible-region
// and correct time-region; spatial part will be cropped by
// bounding-box of bounding-object below
m_InputRequestedRegion = input->GetLargestPossibleRegion();
// build region out of index and size calculated in ComputeNewImageBounds()
mitk::SlicedData::IndexType index;
index[0] = m_RegionIndex[0];
index[1] = m_RegionIndex[1];
index[2] = m_RegionIndex[2];
index[3] = m_InputRequestedRegion.GetIndex()[3];
index[4] = m_InputRequestedRegion.GetIndex()[4];
mitk::SlicedData::SizeType size;
size[0] = m_RegionSize[0];
size[1] = m_RegionSize[1];
size[2] = m_RegionSize[2];
size[3] = m_InputRequestedRegion.GetSize()[3];
size[4] = m_InputRequestedRegion.GetSize()[4];
mitk::SlicedData::RegionType cropRegion(index, size);
// crop input-requested-region with cropping region computed from the image data
if(m_InputRequestedRegion.Crop(cropRegion)==false)
{
// crop not possible => do nothing: set time size to 0.
size.Fill(0);
m_InputRequestedRegion.SetSize(size);
return;
}
// set input-requested-region, because we access it later in
// GenerateInputRequestedRegion (there we just set the time)
input->SetRequestedRegion(&m_InputRequestedRegion);
// PART II: initialize output image
unsigned int dimension = input->GetDimension();
unsigned int *dimensions = new unsigned int [dimension];
itk2vtk(m_InputRequestedRegion.GetSize(), dimensions);
if(dimension>3)
memcpy(dimensions+3, input->GetDimensions()+3, (dimension-3)*sizeof(unsigned int));
// create basic slicedGeometry that will be initialized below
output->Initialize(mitk::PixelType( GetOutputPixelType() ), dimension, dimensions);
delete [] dimensions;
//clone the IndexToWorldTransform from the input, otherwise we will overwrite it, when adjusting the origin of the output image!!
itk::ScalableAffineTransform< mitk::ScalarType,3 >::Pointer cloneTransform = itk::ScalableAffineTransform< mitk::ScalarType,3 >::New();
cloneTransform->Compose(input->GetGeometry()->GetIndexToWorldTransform());
output->GetGeometry()->SetIndexToWorldTransform( cloneTransform.GetPointer() );
// Position the output Image to match the corresponding region of the input image
mitk::SlicedGeometry3D* slicedGeometry = output->GetSlicedGeometry();
mitk::SlicedGeometry3D::Pointer inputGeometry = input->GetSlicedGeometry();
const mitk::SlicedData::IndexType& start = m_InputRequestedRegion.GetIndex();
mitk::Point3D origin; vtk2itk(start, origin);
input->GetSlicedGeometry()->IndexToWorld(origin, origin);
slicedGeometry->SetOrigin(origin);
// get the PlaneGeometry for the first slice of the original image
mitk::PlaneGeometry::Pointer plane = dynamic_cast<mitk::PlaneGeometry*>( inputGeometry->GetGeometry2D( 0 )->Clone().GetPointer() );
assert( plane );
// re-initialize the plane according to the new requirements:
// dimensions of the cropped image
// right- and down-vector as well as spacing do not change, so use the ones from
// input image
ScalarType dimX = output->GetDimensions()[0];
ScalarType dimY = output->GetDimensions()[1];
mitk::Vector3D right = plane->GetAxisVector(0);
mitk::Vector3D down = plane->GetAxisVector(1);
mitk::Vector3D spacing = plane->GetSpacing();
plane->InitializeStandardPlane( dimX, dimY, right, down, &spacing );
// set the new origin on the PlaneGeometry as well
plane->SetOrigin(origin);
// re-initialize the slicedGeometry with the correct planeGeometry
// in order to get a fully initialized SlicedGeometry3D
slicedGeometry->InitializeEvenlySpaced( plane, inputGeometry->GetSpacing()[2], output->GetSlicedGeometry()->GetSlices() );
mitk::TimeGeometry* timeSlicedGeometry = output->GetTimeGeometry();
mitk::ProportionalTimeGeometry* propTimeGeometry = dynamic_cast<ProportionalTimeGeometry*>(timeSlicedGeometry);
propTimeGeometry->Initialize(slicedGeometry, output->GetDimension(3));
m_TimeOfHeaderInitialization.Modified();
output->SetPropertyList(input->GetPropertyList()->Clone());
}
void mitk::ContourModelSetGLMapper2D::InternalDrawContour(mitk::ContourModel *renderingContour,
mitk::BaseRenderer *renderer)
{
if (!renderingContour)
return;
mitk::DataNode *dataNode = this->GetDataNode();
renderingContour->UpdateOutputInformation();
unsigned int timestep = renderer->GetTimeStep();
if (!renderingContour->IsEmptyTimeStep(timestep))
{
// apply color and opacity read from the PropertyList
ApplyColorAndOpacityProperties(renderer);
mitk::ColorProperty::Pointer colorprop =
dynamic_cast<mitk::ColorProperty *>(dataNode->GetProperty("contour.color", renderer));
float opacity = 0.5;
dataNode->GetFloatProperty("opacity", opacity, renderer);
if (colorprop)
{
// set the color of the contour
double red = colorprop->GetColor().GetRed();
double green = colorprop->GetColor().GetGreen();
double blue = colorprop->GetColor().GetBlue();
glColor4f(red, green, blue, opacity);
}
mitk::ColorProperty::Pointer selectedcolor =
dynamic_cast<mitk::ColorProperty *>(dataNode->GetProperty("contour.points.color", renderer));
if (!selectedcolor)
{
selectedcolor = mitk::ColorProperty::New(1.0, 0.0, 0.1);
}
vtkLinearTransform *transform = dataNode->GetVtkTransform();
// ContourModel::OutputType point;
mitk::Point3D point;
mitk::Point3D p;
float vtkp[3];
float lineWidth = 3.0;
bool drawit = false;
bool isHovering = false;
dataNode->GetBoolProperty("contour.hovering", isHovering);
if (isHovering)
dataNode->GetFloatProperty("contour.hovering.width", lineWidth);
else
dataNode->GetFloatProperty("contour.width", lineWidth);
bool showSegments = false;
dataNode->GetBoolProperty("contour.segments.show", showSegments);
bool showControlPoints = false;
dataNode->GetBoolProperty("contour.controlpoints.show", showControlPoints);
bool showPoints = false;
dataNode->GetBoolProperty("contour.points.show", showPoints);
bool showPointsNumbers = false;
dataNode->GetBoolProperty("contour.points.text", showPointsNumbers);
bool showControlPointsNumbers = false;
dataNode->GetBoolProperty("contour.controlpoints.text", showControlPointsNumbers);
bool projectmode = false;
dataNode->GetVisibility(projectmode, renderer, "contour.project-onto-plane");
mitk::ContourModel::VertexIterator pointsIt = renderingContour->IteratorBegin(timestep);
Point2D pt2d; // projected_p in display coordinates
Point2D lastPt2d;
int index = 0;
mitk::ScalarType maxDiff = 0.25;
while (pointsIt != renderingContour->IteratorEnd(timestep))
{
lastPt2d = pt2d;
point = (*pointsIt)->Coordinates;
itk2vtk(point, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp, p);
renderer->WorldToDisplay(p, pt2d);
ScalarType scalardiff = fabs(renderer->GetCurrentWorldPlaneGeometry()->SignedDistance(p));
// project to plane
if (projectmode)
{
drawit = true;
}
else if (scalardiff < maxDiff) // point is close enough to be drawn
{
drawit = true;
}
else
{
drawit = false;
}
// draw line
if (drawit)
{
if (showSegments)
{
// lastPt2d is not valid in first step
if (!(pointsIt == renderingContour->IteratorBegin(timestep)))
{
glLineWidth(lineWidth);
glBegin(GL_LINES);
glVertex2f(pt2d[0], pt2d[1]);
glVertex2f(lastPt2d[0], lastPt2d[1]);
glEnd();
glLineWidth(1);
}
}
if (showControlPoints)
{
// draw ontrol points
if ((*pointsIt)->IsControlPoint)
{
float pointsize = 4;
Point2D tmp;
Vector2D horz, vert;
horz[1] = 0;
vert[0] = 0;
horz[0] = pointsize;
vert[1] = pointsize;
glColor3f(selectedcolor->GetColor().GetRed(),
selectedcolor->GetColor().GetBlue(),
selectedcolor->GetColor().GetGreen());
glLineWidth(1);
// a rectangle around the point with the selected color
glBegin(GL_LINE_LOOP);
tmp = pt2d - horz;
glVertex2dv(&tmp[0]);
tmp = pt2d + vert;
glVertex2dv(&tmp[0]);
tmp = pt2d + horz;
glVertex2dv(&tmp[0]);
tmp = pt2d - vert;
glVertex2dv(&tmp[0]);
glEnd();
glLineWidth(1);
// the actual point in the specified color to see the usual color of the point
glColor3f(
colorprop->GetColor().GetRed(), colorprop->GetColor().GetGreen(), colorprop->GetColor().GetBlue());
glPointSize(1);
glBegin(GL_POINTS);
tmp = pt2d;
glVertex2dv(&tmp[0]);
glEnd();
}
}
if (showPoints)
{
float pointsize = 3;
Point2D tmp;
Vector2D horz, vert;
horz[1] = 0;
vert[0] = 0;
horz[0] = pointsize;
vert[1] = pointsize;
glColor3f(0.0, 0.0, 0.0);
glLineWidth(1);
// a rectangle around the point with the selected color
glBegin(GL_LINE_LOOP);
tmp = pt2d - horz;
glVertex2dv(&tmp[0]);
tmp = pt2d + vert;
glVertex2dv(&tmp[0]);
tmp = pt2d + horz;
glVertex2dv(&tmp[0]);
tmp = pt2d - vert;
glVertex2dv(&tmp[0]);
glEnd();
glLineWidth(1);
// the actual point in the specified color to see the usual color of the point
glColor3f(colorprop->GetColor().GetRed(), colorprop->GetColor().GetGreen(), colorprop->GetColor().GetBlue());
glPointSize(1);
glBegin(GL_POINTS);
tmp = pt2d;
glVertex2dv(&tmp[0]);
glEnd();
}
if (showPointsNumbers)
{
std::string l;
std::stringstream ss;
ss << index;
l.append(ss.str());
float rgb[3];
rgb[0] = 0.0;
rgb[1] = 0.0;
rgb[2] = 0.0;
WriteTextWithAnnotation(m_PointNumbersAnnotation, l.c_str(), rgb, pt2d, renderer);
}
if (showControlPointsNumbers && (*pointsIt)->IsControlPoint)
{
std::string l;
std::stringstream ss;
ss << index;
l.append(ss.str());
float rgb[3];
rgb[0] = 1.0;
rgb[1] = 1.0;
rgb[2] = 0.0;
WriteTextWithAnnotation(m_ControlPointNumbersAnnotation, l.c_str(), rgb, pt2d, renderer);
}
index++;
}
pointsIt++;
} // end while iterate over controlpoints
// close contour if necessary
if (renderingContour->IsClosed(timestep) && drawit && showSegments)
{
lastPt2d = pt2d;
point = renderingContour->GetVertexAt(0, timestep)->Coordinates;
itk2vtk(point, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp, p);
renderer->WorldToDisplay(p, pt2d);
glLineWidth(lineWidth);
glBegin(GL_LINES);
glVertex2f(lastPt2d[0], lastPt2d[1]);
glVertex2f(pt2d[0], pt2d[1]);
glEnd();
glLineWidth(1);
}
// draw selected vertex if exists
if (renderingContour->GetSelectedVertex())
{
// transform selected vertex
point = renderingContour->GetSelectedVertex()->Coordinates;
itk2vtk(point, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp, p);
renderer->WorldToDisplay(p, pt2d);
ScalarType scalardiff = fabs(renderer->GetCurrentWorldPlaneGeometry()->SignedDistance(p));
//----------------------------------
// draw point if close to plane
if (scalardiff < maxDiff)
{
float pointsize = 5;
Point2D tmp;
glColor3f(0.0, 1.0, 0.0);
glLineWidth(1);
// a diamond around the point
glBegin(GL_LINE_LOOP);
// begin from upper left corner and paint clockwise
tmp[0] = pt2d[0] - pointsize;
tmp[1] = pt2d[1] + pointsize;
glVertex2dv(&tmp[0]);
tmp[0] = pt2d[0] + pointsize;
tmp[1] = pt2d[1] + pointsize;
glVertex2dv(&tmp[0]);
tmp[0] = pt2d[0] + pointsize;
tmp[1] = pt2d[1] - pointsize;
glVertex2dv(&tmp[0]);
tmp[0] = pt2d[0] - pointsize;
tmp[1] = pt2d[1] - pointsize;
glVertex2dv(&tmp[0]);
glEnd();
}
//------------------------------------
}
}
}
//##Documentation
//## overwritten cause this class can handle it better!
float mitk::ConnectPointsInteractor::CanHandleEvent(StateEvent const* stateEvent) const
{
float returnValue = 0;
mitk::PositionEvent const *posEvent = dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
//checking if a keyevent can be handled:
if (posEvent == NULL)
{
//check, if the current state has a transition waiting for that key event.
if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
{
return 0.5;
}
else
{
return 0;
}
}
//Mouse event handling:
//on MouseMove do nothing! reimplement if needed differently
if (stateEvent->GetEvent()->GetType() == mitk::Type_MouseMove)
{
return 0;
}
//check on the right data-type
mitk::PointSet* pointSet = dynamic_cast<mitk::PointSet*>(m_DataNode->GetData());
if (pointSet == NULL)
return 0;
//since we now have 3D picking in GlobalInteraction and all events send are DisplayEvents with 3D information,
//we concentrate on 3D coordinates
mitk::Point3D worldPoint = posEvent->GetWorldPosition();
float p[3];
itk2vtk(worldPoint, p);
//transforming the Worldposition to local coordinatesystem
m_DataNode->GetData()->GetGeometry()->GetVtkTransform()->GetInverse()->TransformPoint(p, p);
vtk2itk(p, worldPoint);
float distance = 5;
int index = pointSet->SearchPoint(worldPoint, distance);
if (index>-1)
//how far away is the line from the point?
{
//get the point and calculate the jurisdiction out of it.
mitk::PointSet::PointType point;
pointSet->GetPointSet()->GetPoint(index, &point);
returnValue = point.EuclideanDistanceTo(worldPoint);
//between 1 and 0. 1 if directly hit
returnValue = 1 - ( returnValue / distance );
if (returnValue<0 || returnValue>1)
{
itkWarningMacro("Difficulties in calculating Jurisdiction. Check PointInteractor");
return 0;
}
//and now between 0,5 and 1
returnValue = 0.5 + (returnValue / 2);
return returnValue;
}
else //not found
{
return 0;
}
}
void mitk::MeshMapper2D::Paint(mitk::BaseRenderer *renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if (!visible)
return;
// @FIXME: Logik fuer update
bool updateNeccesary = true;
if (updateNeccesary)
{
// aus GenerateData
mitk::Mesh::Pointer input = const_cast<mitk::Mesh *>(this->GetInput());
// Get the TimeGeometry of the input object
const TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
if ((inputTimeGeometry == NULL) || (inputTimeGeometry->CountTimeSteps() == 0))
{
return;
}
//
// get the world time
//
ScalarType time = renderer->GetTime();
//
// convert the world time in time steps of the input object
//
int timeStep = 0;
if (time > itk::NumericTraits<mitk::ScalarType>::NonpositiveMin())
timeStep = inputTimeGeometry->TimePointToTimeStep(time);
if (inputTimeGeometry->IsValidTimeStep(timeStep) == false)
{
return;
}
mitk::Mesh::MeshType::Pointer itkMesh = input->GetMesh(timeStep);
if (itkMesh.GetPointer() == NULL)
{
return;
}
const PlaneGeometry *worldplanegeometry = (renderer->GetCurrentWorldPlaneGeometry());
// apply color and opacity read from the PropertyList
ApplyColorAndOpacityProperties(renderer);
vtkLinearTransform *transform = GetDataNode()->GetVtkTransform();
// List of the Points
Mesh::DataType::PointsContainerConstIterator it, end;
it = itkMesh->GetPoints()->Begin();
end = itkMesh->GetPoints()->End();
// iterator on the additional data of each point
Mesh::PointDataIterator dataIt; //, dataEnd;
dataIt = itkMesh->GetPointData()->Begin();
// for switching back to old color after using selected color
float unselectedColor[4];
glGetFloatv(GL_CURRENT_COLOR, unselectedColor);
while (it != end)
{
mitk::Point3D p, projected_p;
float vtkp[3];
itk2vtk(it->Value(), vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp, p);
renderer->GetCurrentWorldPlaneGeometry()->Project(p, projected_p);
Vector3D diff = p - projected_p;
if (diff.GetSquaredNorm() < 4.0)
{
Point2D pt2d, tmp;
renderer->WorldToDisplay(p, pt2d);
Vector2D horz, vert;
horz[0] = 5;
horz[1] = 0;
vert[0] = 0;
vert[1] = 5;
// check if the point is to be marked as selected
if (dataIt->Value().selected)
{
horz[0] = 8;
vert[1] = 8;
glColor3f(selectedColor[0], selectedColor[1], selectedColor[2]); // red
switch (dataIt->Value().pointSpec)
{
case PTSTART:
{
// a quad
glBegin(GL_LINE_LOOP);
tmp = pt2d - horz + vert;
glVertex2dv(&tmp[0]);
tmp = pt2d + horz + vert;
glVertex2dv(&tmp[0]);
tmp = pt2d + horz - vert;
glVertex2dv(&tmp[0]);
tmp = pt2d - horz - vert;
glVertex2dv(&tmp[0]);
glEnd();
}
break;
case PTUNDEFINED:
{
// a diamond around the point
glBegin(GL_LINE_LOOP);
tmp = pt2d - horz;
glVertex2dv(&tmp[0]);
tmp = pt2d + vert;
glVertex2dv(&tmp[0]);
tmp = pt2d + horz;
glVertex2dv(&tmp[0]);
tmp = pt2d - vert;
glVertex2dv(&tmp[0]);
glEnd();
}
break;
default:
break;
} // switch
// the actual point
glBegin(GL_POINTS);
tmp = pt2d;
glVertex2dv(&tmp[0]);
glEnd();
}
else // if not selected
{
glColor3f(unselectedColor[0], unselectedColor[1], unselectedColor[2]);
switch (dataIt->Value().pointSpec)
{
case PTSTART:
{
// a quad
glBegin(GL_LINE_LOOP);
tmp = pt2d - horz + vert;
glVertex2dv(&tmp[0]);
tmp = pt2d + horz + vert;
glVertex2dv(&tmp[0]);
tmp = pt2d + horz - vert;
glVertex2dv(&tmp[0]);
tmp = pt2d - horz - vert;
glVertex2dv(&tmp[0]);
glEnd();
}
case PTUNDEFINED:
{
// drawing crosses
glBegin(GL_LINES);
tmp = pt2d - horz;
glVertex2dv(&tmp[0]);
tmp = pt2d + horz;
glVertex2dv(&tmp[0]);
tmp = pt2d - vert;
glVertex2dv(&tmp[0]);
tmp = pt2d + vert;
glVertex2dv(&tmp[0]);
glEnd();
}
default:
{
break;
}
} // switch
} // else
}
++it;
++dataIt;
}
// now connect the lines inbetween
mitk::Mesh::PointType thisPoint;
thisPoint.Fill(0);
Point2D *firstOfCell = NULL;
Point2D *lastPoint = NULL;
unsigned int lastPointId = 0;
bool lineSelected = false;
Point3D firstOfCell3D;
Point3D lastPoint3D;
bool first;
mitk::Line<mitk::ScalarType> line;
std::vector<mitk::Point3D> intersectionPoints;
double t;
// iterate through all cells and then iterate through all indexes of points in that cell
Mesh::CellIterator cellIt, cellEnd;
Mesh::CellDataIterator cellDataIt; //, cellDataEnd;
Mesh::PointIdIterator cellIdIt, cellIdEnd;
cellIt = itkMesh->GetCells()->Begin();
cellEnd = itkMesh->GetCells()->End();
cellDataIt = itkMesh->GetCellData()->Begin();
while (cellIt != cellEnd)
{
unsigned int numOfPointsInCell = cellIt->Value()->GetNumberOfPoints();
if (numOfPointsInCell > 1)
{
// iterate through all id's in the cell
cellIdIt = cellIt->Value()->PointIdsBegin();
cellIdEnd = cellIt->Value()->PointIdsEnd();
firstOfCell3D = input->GetPoint(*cellIdIt, timeStep);
intersectionPoints.clear();
intersectionPoints.reserve(numOfPointsInCell);
first = true;
while (cellIdIt != cellIdEnd)
{
lastPoint3D = thisPoint;
thisPoint = input->GetPoint(*cellIdIt, timeStep);
// search in data (vector<> selectedLines) if the index of the point is set. if so, then the line is selected.
lineSelected = false;
Mesh::SelectedLinesType selectedLines = cellDataIt->Value().selectedLines;
// a line between 1(lastPoint) and 2(pt2d) has the Id 1, so look for the Id of lastPoint
// since we only start, if we have more than one point in the cell, lastPointId is initiated with 0
Mesh::SelectedLinesIter position = std::find(selectedLines.begin(), selectedLines.end(), lastPointId);
if (position != selectedLines.end())
{
lineSelected = true;
}
mitk::Point3D p, projected_p;
float vtkp[3];
itk2vtk(thisPoint, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp, p);
renderer->GetCurrentWorldPlaneGeometry()->Project(p, projected_p);
Vector3D diff = p - projected_p;
if (diff.GetSquaredNorm() < 4.0)
{
Point2D pt2d, tmp;
renderer->WorldToDisplay(p, pt2d);
if (lastPoint == NULL)
{
// set the first point in the cell. This point in needed to close the polygon
firstOfCell = new Point2D;
*firstOfCell = pt2d;
lastPoint = new Point2D;
*lastPoint = pt2d;
lastPointId = *cellIdIt;
}
else
{
if (lineSelected)
{
glColor3f(selectedColor[0], selectedColor[1], selectedColor[2]); // red
// a line from lastPoint to thisPoint
glBegin(GL_LINES);
glVertex2dv(&(*lastPoint)[0]);
glVertex2dv(&pt2d[0]);
glEnd();
}
else // if not selected
{
glColor3f(unselectedColor[0], unselectedColor[1], unselectedColor[2]);
// drawing crosses
glBegin(GL_LINES);
glVertex2dv(&(*lastPoint)[0]);
glVertex2dv(&pt2d[0]);
glEnd();
}
// to draw the line to the next in iteration step
*lastPoint = pt2d;
// and to search for the selection state of the line
lastPointId = *cellIdIt;
} // if..else
} // if <4.0
// fill off-plane polygon part 1
if ((!first) && (worldplanegeometry != NULL))
{
line.SetPoints(lastPoint3D, thisPoint);
if (worldplanegeometry->IntersectionPointParam(line, t) && ((t >= 0) && (t <= 1)))
{
intersectionPoints.push_back(line.GetPoint(t));
}
}
++cellIdIt;
first = false;
} // while cellIdIter
// closed polygon?
if (cellDataIt->Value().closed)
{
// close the polygon if needed
if (firstOfCell != NULL)
{
lineSelected = false;
Mesh::SelectedLinesType selectedLines = cellDataIt->Value().selectedLines;
Mesh::SelectedLinesIter position = std::find(selectedLines.begin(), selectedLines.end(), lastPointId);
if (position != selectedLines.end()) // found the index
{
glColor3f(selectedColor[0], selectedColor[1], selectedColor[2]); // red
// a line from lastPoint to firstPoint
glBegin(GL_LINES);
glVertex2dv(&(*lastPoint)[0]);
glVertex2dv(&(*firstOfCell)[0]);
glEnd();
}
else
{
glColor3f(unselectedColor[0], unselectedColor[1], unselectedColor[2]);
glBegin(GL_LINES);
glVertex2dv(&(*lastPoint)[0]);
glVertex2dv(&(*firstOfCell)[0]);
glEnd();
}
}
} // if closed
// Axis-aligned bounding box(AABB) around the cell if selected and set in Property
bool showBoundingBox;
if (dynamic_cast<mitk::BoolProperty *>(this->GetDataNode()->GetProperty("showBoundingBox")) == NULL)
showBoundingBox = false;
else
showBoundingBox =
dynamic_cast<mitk::BoolProperty *>(this->GetDataNode()->GetProperty("showBoundingBox"))->GetValue();
if (showBoundingBox)
{
if (cellDataIt->Value().selected)
{
mitk::Mesh::DataType::BoundingBoxPointer aABB = input->GetBoundingBoxFromCell(cellIt->Index());
if (aABB.IsNotNull())
{
mitk::Mesh::PointType min, max;
min = aABB->GetMinimum();
max = aABB->GetMaximum();
// project to the displayed geometry
Point2D min2D, max2D;
Point3D p, projected_p;
float vtkp[3];
itk2vtk(min, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp, p);
renderer->WorldToDisplay(p, min2D);
itk2vtk(max, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp, p);
renderer->GetCurrentWorldPlaneGeometry()->Project(p, projected_p);
Vector3D diff = p - projected_p;
if (diff.GetSquaredNorm() < 4.0)
{
renderer->WorldToDisplay(p, max2D);
// draw the BoundingBox
glColor3f(selectedColor[0], selectedColor[1], selectedColor[2]); // red
// a line from lastPoint to firstPoint
glBegin(GL_LINE_LOOP);
glVertex2f(min2D[0], min2D[1]);
glVertex2f(min2D[0], max2D[1]);
glVertex2f(max2D[0], max2D[1]);
glVertex2f(max2D[0], min2D[1]);
glEnd();
} // draw bounding-box
} // bounding-box exists
} // cell selected
} // show bounding-box
// fill off-plane polygon part 2
if (worldplanegeometry != NULL)
{
// consider line from last to first
line.SetPoints(thisPoint, firstOfCell3D);
if (worldplanegeometry->IntersectionPointParam(line, t) && ((t >= 0) && (t <= 1)))
{
intersectionPoints.push_back(line.GetPoint(t));
}
std::sort(intersectionPoints.begin(), intersectionPoints.end(), point3DSmaller);
std::vector<mitk::Point3D>::iterator it, end;
end = intersectionPoints.end();
if ((intersectionPoints.size() % 2) != 0)
{
--end; // ensure even number of intersection-points
}
Point2D pt2d;
for (it = intersectionPoints.begin(); it != end; ++it)
{
glBegin(GL_LINES);
renderer->WorldToDisplay(*it, pt2d);
glVertex2dv(pt2d.GetDataPointer());
++it;
renderer->WorldToDisplay(*it, pt2d);
glVertex2dv(pt2d.GetDataPointer());
glEnd();
}
if (it != intersectionPoints.end())
{
glBegin(GL_LINES);
renderer->WorldToDisplay(*it, pt2d);
glVertex2dv(pt2d.GetDataPointer());
glVertex2dv(pt2d.GetDataPointer());
glEnd();
}
} // fill off-plane polygon part 2
} // if numOfPointsInCell>1
delete firstOfCell;
delete lastPoint;
lastPoint = NULL;
firstOfCell = NULL;
lastPointId = 0;
++cellIt;
++cellDataIt;
}
}
}
void mitk::PlanesPerpendicularToLinesFilter::GenerateData()
{
mitk::Mesh::ConstPointer input = this->GetInput();
mitk::GeometryData::Pointer output = this->GetOutput();
if(m_Plane.IsNotNull())
{
targetRight = m_Plane->GetMatrixColumn(0);
targetSpacing = m_Plane->GetSpacing();
bounds = m_Plane->GetBoundingBox()->GetBounds();
halfWidthInMM = m_Plane->GetExtentInMM(0)*0.5;
halfHeightInMM = m_Plane->GetExtentInMM(1)*0.5;
}
else
{
FillVector3D(targetRight, 1.0, 0.0, 0.0);
targetSpacing.Fill(1.0);
halfWidthInMM=halfHeightInMM=100.0;
ScalarType stdBounds[6] = {0.0, 2.0*halfWidthInMM, 0.0, 2.0*halfHeightInMM, 0.0, 0.0};
bounds = stdBounds;
}
if(m_UseAllPoints==false)
{
int i, size;
//iterate through all cells and build planes
Mesh::ConstCellIterator cellIt, cellEnd;
cellEnd = input->GetMesh()->GetCells()->End();
for( cellIt = input->GetMesh()->GetCells()->Begin(); cellIt != cellEnd; ++cellIt )
{
Mesh::CellType& cell = *cellIt->Value();
Mesh::PointIdIterator ptIt, ptEnd;
ptEnd = cell.PointIdsEnd();
size=cell.GetNumberOfPoints();
if(size<=1)
continue;
ptIt = cell.PointIdsBegin();
last = input->GetPoint(*ptIt);
++ptIt;
for(i=1;i<size;++i, ++ptIt)
{
CreatePlane(input->GetPoint(*ptIt));
}
}
}
else //m_UseAllPoints==true
{
//iterate through all points and build planes
mitk::PointSet::PointsConstIterator it, pend = input->GetPointSet()->GetPoints()->End();
it=input->GetPointSet()->GetPoints()->Begin();
last = it.Value();
++it;
for(;it!=pend;++it)
{
CreatePlane(it.Value());
}
}
if(planes.size()>0)
{
//initialize sliced-geometry for the number of created planes
m_CreatedGeometries->InitializeSlicedGeometry(planes.size()+1);
//set last plane at last point with same normal as the one before the last
PlaneGeometry::Pointer plane = static_cast<PlaneGeometry*>((*planes.rbegin())->Clone().GetPointer());
itk2vtk(last.GetVnlVector()-right*halfWidthInMM-down*halfHeightInMM, origin);
plane->SetOrigin(origin);
m_CreatedGeometries->SetGeometry2D(plane, planes.size());
//add all planes to sliced-geometry
int s;
for(s=0; planes.empty()==false; planes.pop_front(), ++s)
{
m_CreatedGeometries->SetGeometry2D(planes.front(), s);
}
m_CreatedGeometries->SetEvenlySpaced(false);
if(m_FrameGeometry.IsNotNull())
{
m_CreatedGeometries->SetIndexToWorldTransform(m_FrameGeometry->GetIndexToWorldTransform());
m_CreatedGeometries->SetBounds(m_FrameGeometry->GetBounds());
m_CreatedGeometries->SetReferenceGeometry(m_FrameGeometry);
}
}
output->SetGeometry(m_CreatedGeometries);
}
void mitk::ExtrudedContour::BuildGeometry()
{
if(m_Contour.IsNull())
return;
// Initialize(1);
Vector3D nullvector; nullvector.Fill(0.0);
float xProj[3];
unsigned int i;
unsigned int numPts = 20; //m_Contour->GetNumberOfPoints();
mitk::Contour::PathPointer path = m_Contour->GetContourPath();
mitk::Contour::PathType::InputType cstart = path->StartOfInput();
mitk::Contour::PathType::InputType cend = path->EndOfInput();
mitk::Contour::PathType::InputType cstep = (cend-cstart)/numPts;
mitk::Contour::PathType::InputType ccur;
// Part I: guarantee/calculate legal vectors
m_Vector.Normalize();
itk2vtk(m_Vector, m_Normal);
// check m_Vector
if(mitk::Equal(m_Vector, nullvector) || m_AutomaticVectorGeneration)
{
if ( m_AutomaticVectorGeneration == false)
itkWarningMacro("Extrusion vector is 0 ("<< m_Vector << "); trying to use normal of polygon");
vtkPoints *loopPoints = vtkPoints::New();
//mitk::Contour::PointsContainerIterator pointsIt = m_Contour->GetPoints()->Begin();
double vtkpoint[3];
unsigned int i=0;
for(i=0, ccur=cstart; i<numPts; ++i, ccur+=cstep)
{
itk2vtk(path->Evaluate(ccur), vtkpoint);
loopPoints->InsertNextPoint(vtkpoint);
}
// Make sure points define a loop with a m_Normal
vtkPolygon::ComputeNormal(loopPoints, m_Normal);
loopPoints->Delete();
vtk2itk(m_Normal, m_Vector);
if(mitk::Equal(m_Vector, nullvector))
{
itkExceptionMacro("Cannot calculate normal of polygon");
}
}
// check m_RightVector
if((mitk::Equal(m_RightVector, nullvector)) || (mitk::Equal(m_RightVector*m_Vector, 0.0)==false))
{
if(mitk::Equal(m_RightVector, nullvector))
{
itkDebugMacro("Right vector is 0. Calculating.");
}
else
{
itkWarningMacro("Right vector ("<<m_RightVector<<") not perpendicular to extrusion vector "<<m_Vector<<": "<<m_RightVector*m_Vector);
}
// calculate a legal m_RightVector
if( mitk::Equal( m_Vector[1], 0.0f ) == false )
{
FillVector3D( m_RightVector, 1.0f, -m_Vector[0]/m_Vector[1], 0.0f );
m_RightVector.Normalize();
}
else
{
FillVector3D( m_RightVector, 0.0f, 1.0f, 0.0f );
}
}
// calculate down-vector
VnlVector rightDV = m_RightVector.GetVnlVector(); rightDV.normalize(); vnl2vtk(rightDV, m_Right);
VnlVector downDV = vnl_cross_3d( m_Vector.GetVnlVector(), rightDV ); downDV.normalize(); vnl2vtk(downDV, m_Down);
// Part II: calculate plane as base for extrusion, project the contour
// on this plane and store as polygon for IsInside test and BoundingBox calculation
// initialize m_ProjectionPlane, yet with origin at 0
m_ProjectionPlane->InitializeStandardPlane(rightDV, downDV);
// create vtkPolygon from contour and simultaneously determine 2D bounds of
// contour projected on m_ProjectionPlane
//mitk::Contour::PointsContainerIterator pointsIt = m_Contour->GetPoints()->Begin();
m_Polygon->Points->Reset();
m_Polygon->Points->SetNumberOfPoints(numPts);
m_Polygon->PointIds->Reset();
m_Polygon->PointIds->SetNumberOfIds(numPts);
mitk::Point2D pt2d;
mitk::Point3D pt3d;
mitk::Point2D min, max;
min.Fill(ScalarTypeNumericTraits::max());
max.Fill(ScalarTypeNumericTraits::min());
xProj[2]=0.0;
for(i=0, ccur=cstart; i<numPts; ++i, ccur+=cstep)
{
pt3d.CastFrom(path->Evaluate(ccur));
m_ProjectionPlane->Map(pt3d, pt2d);
xProj[0]=pt2d[0];
if(pt2d[0]<min[0]) min[0]=pt2d[0];
if(pt2d[0]>max[0]) max[0]=pt2d[0];
xProj[1]=pt2d[1];
if(pt2d[1]<min[1]) min[1]=pt2d[1];
if(pt2d[1]>max[1]) max[1]=pt2d[1];
m_Polygon->Points->SetPoint(i, xProj);
m_Polygon->PointIds->SetId(i, i);
}
// shift parametric origin to (0,0)
for(i=0; i<numPts; ++i)
{
double * pt = this->m_Polygon->Points->GetPoint(i);
pt[0]-=min[0]; pt[1]-=min[1];
itkDebugMacro( << i << ": (" << pt[0] << "," << pt[1] << "," << pt[2] << ")" );
}
this->m_Polygon->GetBounds(m_ProjectedContourBounds);
//m_ProjectedContourBounds[4]=-1.0; m_ProjectedContourBounds[5]=1.0;
// calculate origin (except translation along the normal) and bounds
// of m_ProjectionPlane:
// origin is composed of the minimum x-/y-coordinates of the polygon,
// bounds from the extent of the polygon, both after projecting on the plane
mitk::Point3D origin;
m_ProjectionPlane->Map(min, origin);
ScalarType bounds[6]={0, max[0]-min[0], 0, max[1]-min[1], 0, 1};
m_ProjectionPlane->SetBounds(bounds);
m_ProjectionPlane->SetOrigin(origin);
// Part III: initialize geometry
if(m_ClippingGeometry.IsNotNull())
{
ScalarType min_dist=ScalarTypeNumericTraits::max(), max_dist=ScalarTypeNumericTraits::min(), dist;
unsigned char i;
for(i=0; i<8; ++i)
{
dist = m_ProjectionPlane->SignedDistance( m_ClippingGeometry->GetCornerPoint(i) );
if(dist<min_dist) min_dist=dist;
if(dist>max_dist) max_dist=dist;
}
//incorporate translation along the normal into origin
origin = origin+m_Vector*min_dist;
m_ProjectionPlane->SetOrigin(origin);
bounds[5]=max_dist-min_dist;
}
else
bounds[5]=20;
itk2vtk(origin, m_Origin);
mitk::Geometry3D::Pointer g3d = GetGeometry( 0 );
assert( g3d.IsNotNull() );
g3d->SetBounds(bounds);
g3d->SetIndexToWorldTransform(m_ProjectionPlane->GetIndexToWorldTransform());
g3d->TransferItkToVtkTransform();
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(g3d,1);
SetTimeGeometry(timeGeometry);
}
void mitk::ContourMapper2D::Paint(mitk::BaseRenderer * renderer)
{
if(IsVisible(renderer)==false) return;
//// @FIXME: Logik fuer update
bool updateNeccesary=true;
if (updateNeccesary)
{
mitk::Contour::Pointer input = const_cast<mitk::Contour*>(this->GetInput());
// ok, das ist aus GenerateData kopiert
mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
assert(displayGeometry.IsNotNull());
//apply color and opacity read from the PropertyList
ApplyProperties(renderer);
vtkLinearTransform* transform = GetDataNode()->GetVtkTransform();
// Contour::OutputType point;
Contour::BoundingBoxType::PointType point;
mitk::Point3D p, projected_p;
float vtkp[3];
float lineWidth = 3.0;
if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("Width")) != NULL)
lineWidth = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("Width"))->GetValue();
glLineWidth(lineWidth);
if (input->GetClosed())
{
glBegin (GL_LINE_LOOP);
}
else
{
glBegin (GL_LINE_STRIP);
}
//Contour::InputType end = input->GetContourPath()->EndOfInput();
//if (end > 50000) end = 0;
mitk::Contour::PointsContainerPointer points = input->GetPoints();
mitk::Contour::PointsContainerIterator pointsIt = points->Begin();
while ( pointsIt != points->End() )
{
//while ( idx != end )
//{
// point = input->GetContourPath()->Evaluate(idx);
point = pointsIt.Value();
itk2vtk(point, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp,p);
displayGeometry->Project(p, projected_p);
bool projectmode=false;
GetDataNode()->GetVisibility(projectmode, renderer, "project");
bool drawit=false;
if(projectmode)
drawit=true;
else
{
Vector3D diff=p-projected_p;
if(diff.GetSquaredNorm()<1.0)
drawit=true;
}
if(drawit)
{
Point2D pt2d, tmp;
displayGeometry->Map(projected_p, pt2d);
displayGeometry->WorldToDisplay(pt2d, pt2d);
glVertex2f(pt2d[0], pt2d[1]);
}
pointsIt++;
// idx += 1;
}
glEnd ();
glLineWidth(1.0);
}
}
void BoundingObjectCutter::GenerateOutputInformation()
{
mitk::Image::Pointer output = this->GetOutput();
if ((output->IsInitialized()) && (output->GetPipelineMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
return;
mitk::Image::Pointer input = const_cast< mitk::Image * > ( this->GetInput() );
if(input.IsNull())
{
MITK_WARN << "Input is not a mitk::Image";
return;
}
itkDebugMacro(<<"GenerateOutputInformation()");
unsigned int dimension = input->GetDimension();
if (dimension < 3)
{
MITK_WARN << "ImageCropper cannot handle 1D or 2D Objects. Operation aborted.";
return;
}
if((m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeGeometry()->CountTimeSteps() == 0))
return;
mitk::BaseGeometry* boGeometry = m_BoundingObject->GetGeometry();
mitk::BaseGeometry* inputImageGeometry = input->GetSlicedGeometry();
// calculate bounding box of bounding-object relative to the geometry
// of the input image. The result is in pixel coordinates of the input
// image (because the m_IndexToWorldTransform includes the spacing).
mitk::BoundingBox::Pointer boBoxRelativeToImage = boGeometry->CalculateBoundingBoxRelativeToTransform( inputImageGeometry->GetIndexToWorldTransform() );
// PART I: initialize input requested region. We do this already here (and not
// later when GenerateInputRequestedRegion() is called), because we
// also need the information to setup the output.
// pre-initialize input-requested-region to largest-possible-region
// and correct time-region; spatial part will be cropped by
// bounding-box of bounding-object below
m_InputRequestedRegion = input->GetLargestPossibleRegion();
// build region out of bounding-box of bounding-object
mitk::SlicedData::IndexType index=m_InputRequestedRegion.GetIndex(); //init times and channels
mitk::BoundingBox::PointType min = boBoxRelativeToImage->GetMinimum();
index[0] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[0]));
index[1] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[1]));
index[2] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[2]));
mitk::SlicedData::SizeType size = m_InputRequestedRegion.GetSize(); //init times and channels
mitk::BoundingBox::PointType max = boBoxRelativeToImage->GetMaximum();
size[0] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[0])-index[0]);
size[1] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[1])-index[1]);
size[2] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[2])-index[2]);
mitk::SlicedData::RegionType boRegion(index, size);
if(m_UseWholeInputRegion == false)
{
// crop input-requested-region with region of bounding-object
if(m_InputRequestedRegion.Crop(boRegion)==false)
{
// crop not possible => do nothing: set time size to 0.
size.Fill(0);
m_InputRequestedRegion.SetSize(size);
boRegion.SetSize(size);
m_BoundingObject->SetRequestedRegion(&boRegion);
return;
}
}
// set input-requested-region, because we access it later in
// GenerateInputRequestedRegion (there we just set the time)
input->SetRequestedRegion(&m_InputRequestedRegion);
// PART II: initialize output image
unsigned int *dimensions = new unsigned int [dimension];
itk2vtk(m_InputRequestedRegion.GetSize(), dimensions);
if(dimension>3)
memcpy(dimensions+3, input->GetDimensions()+3, (dimension-3)*sizeof(unsigned int));
output->Initialize(mitk::PixelType(GetOutputPixelType()), dimension, dimensions);
delete [] dimensions;
// now we have everything to initialize the transform of the output
mitk::SlicedGeometry3D* slicedGeometry = output->GetSlicedGeometry();
// set the transform: use the transform of the input;
// the origin will be replaced afterwards
AffineTransform3D::Pointer indexToWorldTransform = AffineTransform3D::New();
indexToWorldTransform->SetParameters(input->GetSlicedGeometry()->GetIndexToWorldTransform()->GetParameters());
slicedGeometry->SetIndexToWorldTransform(indexToWorldTransform);
// Position the output Image to match the corresponding region of the input image
const mitk::SlicedData::IndexType& start = m_InputRequestedRegion.GetIndex();
mitk::Point3D origin;
vtk2itk(start, origin);
inputImageGeometry->IndexToWorld(origin, origin);
slicedGeometry->SetOrigin(origin);
m_TimeOfHeaderInitialization.Modified();
}
void mitk::ContourVtkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer* renderer)
{
if ( IsVisible(renderer)==false )
{
m_Actor->VisibilityOff();
return;
}
m_Actor->VisibilityOn();
m_Contour = vtkPolyData::New();
mitk::Contour::Pointer input = const_cast<mitk::Contour*>(this->GetInput());
bool makeContour = true;
if ( makeContour )
{
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
int numPts=input->GetNumberOfPoints();
if ( numPts > 200000 )
numPts = 200000;
mitk::Contour::PathPointer path = input->GetContourPath();
mitk::Contour::PathType::InputType cstart = path->StartOfInput();
mitk::Contour::PathType::InputType cend = path->EndOfInput();
mitk::Contour::PathType::InputType cstep = (cend-cstart+1)/numPts;
mitk::Contour::PathType::InputType ccur;
vtkIdType ptIndex = 0;
vtkIdType lastPointIndex = 0;
mitk::Contour::PointsContainerPointer contourPoints = input->GetPoints();
mitk::Contour::PointsContainerIterator pointsIt = contourPoints->Begin();
vtkFloatingPointType vtkpoint[3];
int i;
float pointSize = 2;
this->GetDataNode()->GetFloatProperty("spheres size", pointSize);
bool showPoints = true;
this->GetDataNode()->GetBoolProperty("show points", showPoints);
if ( showPoints )
{
m_VtkPointList = vtkAppendPolyData::New();
}
for ( i=0, ccur=cstart; i<numPts; ++i, ccur+=cstep )
{
itk2vtk(path->Evaluate(ccur), vtkpoint);
points->InsertPoint(ptIndex, vtkpoint);
if ( ptIndex > 0 )
{
int cell[2] = {ptIndex-1,ptIndex};
lines->InsertNextCell((vtkIdType)2,(vtkIdType*) cell);
}
lastPointIndex = ptIndex;
++ptIndex;
if ( showPoints )
{
vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
sphere->SetRadius(pointSize);
sphere->SetCenter(vtkpoint);
m_VtkPointList->AddInput(sphere->GetOutput());
sphere->Update();
}
}
if ( input->GetClosed() )
{
int cell[2] = {lastPointIndex,0};
lines->InsertNextCell((vtkIdType)2,(vtkIdType*) cell);
}
m_Contour->SetPoints(points);
m_Contour->SetLines(lines);
m_Contour->Update();
m_TubeFilter->SetInput(m_Contour);
m_TubeFilter->SetRadius(pointSize / 2.0f);
m_TubeFilter->SetNumberOfSides(8);
m_TubeFilter->Update();
if ( showPoints )
{
m_VtkPointList->AddInput(m_TubeFilter->GetOutput());
m_VtkPolyDataMapper->SetInput(m_VtkPointList->GetOutput());
}
else
{
m_VtkPolyDataMapper->SetInput(m_TubeFilter->GetOutput());
}
vtkFloatingPointType rgba[4]={0.0f,1.0f,0.0f,0.6f};
m_Actor->GetProperty()->SetColor(rgba);
m_Actor->SetMapper(m_VtkPolyDataMapper);
}
SetVtkMapperImmediateModeRendering(m_VtkPolyDataMapper);
}
void mitk::PointSetVtkMapper2D::CreateVTKRenderObjects(mitk::BaseRenderer* renderer)
{
LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
unsigned i = 0;
// The vtk text actors need to be removed manually from the propassembly
// since the same vtk text actors are not overwriten within this function,
// but new actors are added to the propassembly each time this function is executed.
// Thus, the actors from the last call must be removed in the beginning.
for(i=0; i< ls->m_VtkTextLabelActors.size(); i++)
{
if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextLabelActors.at(i)))
ls->m_PropAssembly->RemovePart(ls->m_VtkTextLabelActors.at(i));
}
for(i=0; i< ls->m_VtkTextDistanceActors.size(); i++)
{
if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextDistanceActors.at(i)))
ls->m_PropAssembly->RemovePart(ls->m_VtkTextDistanceActors.at(i));
}
for(i=0; i< ls->m_VtkTextAngleActors.size(); i++)
{
if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextAngleActors.at(i)))
ls->m_PropAssembly->RemovePart(ls->m_VtkTextAngleActors.at(i));
}
// initialize polydata here, otherwise we have update problems when
// executing this function again
ls->m_VtkUnselectedPointListPolyData = vtkSmartPointer<vtkPolyData>::New();
ls->m_VtkSelectedPointListPolyData = vtkSmartPointer <vtkPolyData>::New();
ls->m_VtkContourPolyData = vtkSmartPointer<vtkPolyData>::New();
// get input point set and update the PointSet
mitk::PointSet::Pointer input = const_cast<mitk::PointSet*>(this->GetInput());
// only update the input data, if the property tells us to
bool update = true;
this->GetDataNode()->GetBoolProperty("updateDataOnRender", update);
if (update == true)
input->Update();
int timestep = this->GetTimestep();
mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timestep );
if ( itkPointSet.GetPointer() == NULL)
{
ls->m_PropAssembly->VisibilityOff();
return;
}
//iterator for point set
mitk::PointSet::PointsContainer::Iterator pointsIter = itkPointSet->GetPoints()->Begin();
// PointDataContainer has additional information to each point, e.g. whether
// it is selected or not
mitk::PointSet::PointDataContainer::Iterator pointDataIter;
pointDataIter = itkPointSet->GetPointData()->Begin();
//check if the list for the PointDataContainer is the same size as the PointsContainer.
//If not, then the points were inserted manually and can not be visualized according to the PointData (selected/unselected)
bool pointDataBroken = (itkPointSet->GetPointData()->Size() != itkPointSet->GetPoints()->Size());
if( itkPointSet->GetPointData()->size() == 0 || pointDataBroken)
{
ls->m_PropAssembly->VisibilityOff();
return;
}
ls->m_PropAssembly->VisibilityOn();
// empty point sets, cellarrays, scalars
ls->m_UnselectedPoints->Reset();
ls->m_SelectedPoints->Reset();
ls->m_ContourPoints->Reset();
ls->m_ContourLines->Reset();
ls->m_UnselectedScales->Reset();
ls->m_SelectedScales->Reset();
ls->m_DistancesBetweenPoints->Reset();
ls->m_VtkTextLabelActors.clear();
ls->m_VtkTextDistanceActors.clear();
ls->m_VtkTextAngleActors.clear();
ls->m_UnselectedScales->SetNumberOfComponents(3);
ls->m_SelectedScales->SetNumberOfComponents(3);
int NumberContourPoints = 0;
bool pointsOnSameSideOfPlane = false;
const int text2dDistance = 10;
// initialize points with a random start value
// current point in point set
itk::Point<ScalarType> point = pointsIter->Value();
mitk::Point3D p = point; // currently visited point
mitk::Point3D lastP = point; // last visited point (predecessor in point set of "point")
mitk::Vector3D vec; // p - lastP
mitk::Vector3D lastVec; // lastP - point before lastP
vec.Fill(0.0);
lastVec.Fill(0.0);
mitk::Point3D projected_p = point; // p projected on viewplane
mitk::Point2D pt2d;
pt2d[0] = point[0]; // projected_p in display coordinates
pt2d[1] = point[1];
mitk::Point2D lastPt2d = pt2d; // last projected_p in display coordinates (predecessor in point set of "pt2d")
mitk::Point2D preLastPt2d = pt2d ; // projected_p in display coordinates before lastPt2
mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
const mitk::PlaneGeometry* geo2D = renderer->GetCurrentWorldPlaneGeometry();
vtkLinearTransform* dataNodeTransform = input->GetGeometry()->GetVtkTransform();
int count = 0;
for (pointsIter=itkPointSet->GetPoints()->Begin();
pointsIter!=itkPointSet->GetPoints()->End();
pointsIter++)
{
lastP = p; // valid for number of points count > 0
preLastPt2d = lastPt2d; // valid only for count > 1
lastPt2d = pt2d; // valid for number of points count > 0
lastVec = vec; // valid only for counter > 1
// get current point in point set
point = pointsIter->Value();
// transform point
{
float vtkp[3];
itk2vtk(point, vtkp);
dataNodeTransform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp,point);
}
p[0] = point[0];
p[1] = point[1];
p[2] = point[2];
displayGeometry->Project(p, projected_p);
displayGeometry->Map(projected_p, pt2d);
displayGeometry->WorldToDisplay(pt2d, pt2d);
vec = p-lastP; // valid only for counter > 0
// compute distance to current plane
float diff = geo2D->Distance(point);
diff = diff * diff;
//draw markers on slices a certain distance away from the points
//location according to the tolerance threshold (m_DistanceToPlane)
if(diff < m_DistanceToPlane)
{
// is point selected or not?
if (pointDataIter->Value().selected)
{
ls->m_SelectedPoints->InsertNextPoint(point[0],point[1],point[2]);
// point is scaled according to its distance to the plane
ls->m_SelectedScales->InsertNextTuple3(m_Point2DSize - (2*diff),0,0);
}
else
{
ls->m_UnselectedPoints->InsertNextPoint(point[0],point[1],point[2]);
// point is scaled according to its distance to the plane
ls->m_UnselectedScales->InsertNextTuple3(m_Point2DSize - (2*diff),0,0);
}
//---- LABEL -----//
//paint label for each point if available
if (dynamic_cast<mitk::StringProperty *>(this->GetDataNode()->GetProperty("label")) != NULL)
{
const char * pointLabel = dynamic_cast<mitk::StringProperty *>(
this->GetDataNode()->GetProperty("label"))->GetValue();
std::string l = pointLabel;
if (input->GetSize()>1)
{
std::stringstream ss;
ss << pointsIter->Index();
l.append(ss.str());
}
ls->m_VtkTextActor = vtkSmartPointer<vtkTextActor>::New();
ls->m_VtkTextActor->SetPosition(pt2d[0] + text2dDistance, pt2d[1] + text2dDistance);
ls->m_VtkTextActor->SetInput(l.c_str());
ls->m_VtkTextActor->GetTextProperty()->SetOpacity( 100 );
float unselectedColor[4] = {1.0, 1.0, 0.0, 1.0};
//check if there is a color property
GetDataNode()->GetColor(unselectedColor);
ls->m_VtkTextActor->GetTextProperty()->SetColor(unselectedColor[0], unselectedColor[1], unselectedColor[2]);
ls->m_VtkTextLabelActors.push_back(ls->m_VtkTextActor);
}
}
// draw contour, distance text and angle text in render window
// lines between points, which intersect the current plane, are drawn
if( m_ShowContour && count > 0 )
{
ScalarType distance = displayGeometry->GetWorldGeometry()->SignedDistance(point);
ScalarType lastDistance = displayGeometry->GetWorldGeometry()->SignedDistance(lastP);
pointsOnSameSideOfPlane = (distance * lastDistance) > 0.5;
// Points must be on different side of plane in order to draw a contour.
// If "show distant lines" is enabled this condition is disregarded.
if ( !pointsOnSameSideOfPlane || m_ShowDistantLines)
{
vtkSmartPointer<vtkLine> line = vtkSmartPointer<vtkLine>::New();
ls->m_ContourPoints->InsertNextPoint(lastP[0],lastP[1],lastP[2]);
line->GetPointIds()->SetId(0, NumberContourPoints);
NumberContourPoints++;
ls->m_ContourPoints->InsertNextPoint(point[0], point[1], point[2]);
line->GetPointIds()->SetId(1, NumberContourPoints);
NumberContourPoints++;
ls->m_ContourLines->InsertNextCell(line);
if(m_ShowDistances) // calculate and print distance between adjacent points
{
float distancePoints = point.EuclideanDistanceTo(lastP);
std::stringstream buffer;
buffer<<std::fixed <<std::setprecision(m_DistancesDecimalDigits)<<distancePoints<<" mm";
// compute desired display position of text
Vector2D vec2d = pt2d-lastPt2d;
makePerpendicularVector2D(vec2d, vec2d); // text is rendered within text2dDistance perpendicular to current line
Vector2D pos2d = (lastPt2d.GetVectorFromOrigin() + pt2d.GetVectorFromOrigin() ) * 0.5 + vec2d * text2dDistance;
ls->m_VtkTextActor = vtkSmartPointer<vtkTextActor>::New();
ls->m_VtkTextActor->SetPosition(pos2d[0],pos2d[1]);
ls->m_VtkTextActor->SetInput(buffer.str().c_str());
ls->m_VtkTextActor->GetTextProperty()->SetColor(0.0, 1.0, 0.0);
ls->m_VtkTextDistanceActors.push_back(ls->m_VtkTextActor);
}
if(m_ShowAngles && count > 1) // calculate and print angle between connected lines
{
std::stringstream buffer;
buffer << angle(vec.GetVnlVector(), -lastVec.GetVnlVector())*180/vnl_math::pi << "°";
//compute desired display position of text
Vector2D vec2d = pt2d-lastPt2d; // first arm enclosing the angle
vec2d.Normalize();
Vector2D lastVec2d = lastPt2d-preLastPt2d; // second arm enclosing the angle
lastVec2d.Normalize();
vec2d=vec2d-lastVec2d; // vector connecting both arms
vec2d.Normalize();
// middle between two vectors that enclose the angle
Vector2D pos2d = lastPt2d.GetVectorFromOrigin() + vec2d * text2dDistance * text2dDistance;
ls->m_VtkTextActor = vtkSmartPointer<vtkTextActor>::New();
ls->m_VtkTextActor->SetPosition(pos2d[0],pos2d[1]);
ls->m_VtkTextActor->SetInput(buffer.str().c_str());
ls->m_VtkTextActor->GetTextProperty()->SetColor(0.0, 1.0, 0.0);
ls->m_VtkTextAngleActors.push_back(ls->m_VtkTextActor);
}
}
}
if(pointDataIter != itkPointSet->GetPointData()->End())
{
pointDataIter++;
count++;
}
}
// add each single text actor to the assembly
for(i=0; i< ls->m_VtkTextLabelActors.size(); i++)
{
ls->m_PropAssembly->AddPart(ls->m_VtkTextLabelActors.at(i));
}
for(i=0; i< ls->m_VtkTextDistanceActors.size(); i++)
{
ls->m_PropAssembly->AddPart(ls->m_VtkTextDistanceActors.at(i));
}
for(i=0; i< ls->m_VtkTextAngleActors.size(); i++)
{
ls->m_PropAssembly->AddPart(ls->m_VtkTextAngleActors.at(i));
}
//---- CONTOUR -----//
//create lines between the points which intersect the plane
if (m_ShowContour)
{
// draw line between first and last point which is rendered
if(m_CloseContour && NumberContourPoints > 1){
vtkSmartPointer<vtkLine> closingLine = vtkSmartPointer<vtkLine>::New();
closingLine->GetPointIds()->SetId(0, 0); // index of first point
closingLine->GetPointIds()->SetId(1, NumberContourPoints-1); // index of last point
ls->m_ContourLines->InsertNextCell(closingLine);
}
ls->m_VtkContourPolyData->SetPoints(ls->m_ContourPoints);
ls->m_VtkContourPolyData->SetLines(ls->m_ContourLines);
ls->m_VtkContourPolyDataMapper->SetInputData(ls->m_VtkContourPolyData);
ls->m_ContourActor->SetMapper(ls->m_VtkContourPolyDataMapper);
ls->m_ContourActor->GetProperty()->SetLineWidth(m_LineWidth);
ls->m_PropAssembly->AddPart(ls->m_ContourActor);
}
// the point set must be transformed in order to obtain the appropriate glyph orientation
// according to the current view
vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
vtkSmartPointer<vtkMatrix4x4> a,b = vtkSmartPointer<vtkMatrix4x4>::New();
a = geo2D->GetVtkTransform()->GetMatrix();
b->DeepCopy( a );
// delete transformation from matrix, only take orientation
b->SetElement(3,3,1);
b->SetElement(2,3,0);
b->SetElement(1,3,0);
b->SetElement(0,3,0);
b->SetElement(3,2,0);
b->SetElement(3,1,0);
b->SetElement(3,0,0);
transform->SetMatrix( b );
//---- UNSELECTED POINTS -----//
// apply properties to glyph
ls->m_UnselectedGlyphSource2D->SetGlyphType(m_IDShapeProperty);
if(m_FillShape)
ls->m_UnselectedGlyphSource2D->FilledOn();
else
ls->m_UnselectedGlyphSource2D->FilledOff();
// apply transform
vtkSmartPointer<vtkTransformFilter> transformFilterU = vtkSmartPointer<vtkTransformFilter>::New();
transformFilterU->SetInputConnection(ls->m_UnselectedGlyphSource2D->GetOutputPort());
transformFilterU->SetTransform(transform);
ls->m_VtkUnselectedPointListPolyData->SetPoints(ls->m_UnselectedPoints);
ls->m_VtkUnselectedPointListPolyData->GetPointData()->SetVectors(ls->m_UnselectedScales);
// apply transform of current plane to glyphs
ls->m_UnselectedGlyph3D->SetSourceConnection(transformFilterU->GetOutputPort());
ls->m_UnselectedGlyph3D->SetInputData(ls->m_VtkUnselectedPointListPolyData);
ls->m_UnselectedGlyph3D->SetScaleModeToScaleByVector();
ls->m_UnselectedGlyph3D->SetVectorModeToUseVector();
ls->m_VtkUnselectedPolyDataMapper->SetInputConnection(ls->m_UnselectedGlyph3D->GetOutputPort());
ls->m_UnselectedActor->SetMapper(ls->m_VtkUnselectedPolyDataMapper);
ls->m_UnselectedActor->GetProperty()->SetLineWidth(m_PointLineWidth);
ls->m_PropAssembly->AddPart(ls->m_UnselectedActor);
//---- SELECTED POINTS -----//
ls->m_SelectedGlyphSource2D->SetGlyphTypeToDiamond();
ls->m_SelectedGlyphSource2D->CrossOn();
ls->m_SelectedGlyphSource2D->FilledOff();
// apply transform
vtkSmartPointer<vtkTransformFilter> transformFilterS = vtkSmartPointer<vtkTransformFilter>::New();
transformFilterS->SetInputConnection(ls->m_SelectedGlyphSource2D->GetOutputPort());
transformFilterS->SetTransform(transform);
ls->m_VtkSelectedPointListPolyData->SetPoints(ls->m_SelectedPoints);
ls->m_VtkSelectedPointListPolyData->GetPointData()->SetVectors(ls->m_SelectedScales);
// apply transform of current plane to glyphs
ls->m_SelectedGlyph3D->SetSourceConnection(transformFilterS->GetOutputPort());
ls->m_SelectedGlyph3D->SetInputData(ls->m_VtkSelectedPointListPolyData);
ls->m_SelectedGlyph3D->SetScaleModeToScaleByVector();
ls->m_SelectedGlyph3D->SetVectorModeToUseVector();
ls->m_VtkSelectedPolyDataMapper->SetInputConnection(ls->m_SelectedGlyph3D->GetOutputPort());
ls->m_SelectedActor->SetMapper(ls->m_VtkSelectedPolyDataMapper);
ls->m_SelectedActor->GetProperty()->SetLineWidth(m_PointLineWidth);
ls->m_PropAssembly->AddPart(ls->m_SelectedActor);
}
void mitk::ContourSetMapper2D::Paint(mitk::BaseRenderer *renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if (!visible)
return;
//// @FIXME: Logik fuer update
bool updateNeccesary = true;
if (updateNeccesary)
{
// apply color and opacity read from the PropertyList
ApplyColorAndOpacityProperties(renderer);
mitk::ContourSet::Pointer input = const_cast<mitk::ContourSet *>(this->GetInput());
mitk::ContourSet::ContourVectorType contourVec = input->GetContours();
mitk::ContourSet::ContourIterator contourIt = contourVec.begin();
while (contourIt != contourVec.end())
{
mitk::Contour::Pointer nextContour = (mitk::Contour::Pointer)(*contourIt).second;
vtkLinearTransform *transform = GetDataNode()->GetVtkTransform();
// Contour::OutputType point;
Contour::BoundingBoxType::PointType point;
mitk::Point3D p, projected_p;
float vtkp[3];
glLineWidth(nextContour->GetWidth());
if (nextContour->GetClosed())
{
glBegin(GL_LINE_LOOP);
}
else
{
glBegin(GL_LINE_STRIP);
}
// float rgba[4]={1.0f,1.0f,1.0f,1.0f};
// if ( nextContour->GetSelected() )
//{
// rgba[0] = 1.0;
// rgba[1] = 0.0;
// rgba[2] = 0.0;
//}
// glColor4fv(rgba);
mitk::Contour::PointsContainerPointer points = nextContour->GetPoints();
mitk::Contour::PointsContainerIterator pointsIt = points->Begin();
while (pointsIt != points->End())
{
point = pointsIt.Value();
itk2vtk(point, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp, p);
renderer->GetCurrentWorldPlaneGeometry()->Project(p, projected_p);
Vector3D diff = p - projected_p;
if (diff.GetSquaredNorm() < 1.0)
{
Point2D pt2d, tmp;
renderer->WorldToDisplay(p, pt2d);
glVertex2f(pt2d[0], pt2d[1]);
}
pointsIt++;
// idx += 1;
}
glEnd();
glLineWidth(1.0);
contourIt++;
}
}
}
