void mitk::SurfaceGLMapper2D::ApplyAllProperties(mitk::BaseRenderer* renderer)
{
ApplyColorAndOpacityProperties(renderer);
DataNode * node = GetDataNode();
if(node == NULL)
{
return;
}
node->GetBoolProperty("draw normals 2D", m_DrawNormals, renderer);
// check for color and opacity properties, use it for rendering if they exists
node->GetColor(m_LineColor, renderer, "color");
node->GetOpacity(m_LineColor[3], renderer, "opacity");
bool invertNormals(false);
node->GetBoolProperty("invert normals", invertNormals, renderer);
if (!invertNormals)
{
node->GetColor(m_FrontSideColor, renderer, "front color");
node->GetOpacity(m_FrontSideColor[3], renderer, "opacity");
node->GetColor(m_BackSideColor, renderer, "back color");
node->GetOpacity(m_BackSideColor[3], renderer, "opacity");
node->GetFloatProperty( "front normal lenth (px)", m_FrontNormalLengthInPixels, renderer );
node->GetFloatProperty( "back normal lenth (px)", m_BackNormalLengthInPixels, renderer );
}
else
{
node->GetColor(m_FrontSideColor, renderer, "back color");
node->GetOpacity(m_FrontSideColor[3], renderer, "opacity");
node->GetColor(m_BackSideColor, renderer, "front color");
node->GetOpacity(m_BackSideColor[3], renderer, "opacity");
node->GetFloatProperty( "back normal lenth (px)", m_FrontNormalLengthInPixels, renderer );
node->GetFloatProperty( "front normal lenth (px)", m_BackNormalLengthInPixels, renderer );
}
}
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();
}
//------------------------------------
}
}
}
void mitk::UnstructuredGridVtkMapper3D::ApplyProperties(vtkActor* /*actor*/, mitk::BaseRenderer* renderer)
{
mitk::DataNode::Pointer node = this->GetDataNode();
ApplyColorAndOpacityProperties(renderer, m_Actor);
ApplyColorAndOpacityProperties(renderer, m_ActorWireframe);
vtkVolumeProperty* volProp = m_Volume->GetProperty();
vtkProperty* property = m_Actor->GetProperty();
vtkProperty* wireframeProp = m_ActorWireframe->GetProperty();
mitk::SurfaceVtkMapper3D::ApplyMitkPropertiesToVtkProperty(node,property,renderer);
mitk::SurfaceVtkMapper3D::ApplyMitkPropertiesToVtkProperty(node,wireframeProp,renderer);
mitk::TransferFunctionProperty::Pointer transferFuncProp;
if (node->GetProperty(transferFuncProp, "TransferFunction", renderer))
{
mitk::TransferFunction::Pointer transferFunction = transferFuncProp->GetValue();
volProp->SetColor(transferFunction->GetColorTransferFunction());
volProp->SetScalarOpacity(transferFunction->GetScalarOpacityFunction());
volProp->SetGradientOpacity(transferFunction->GetGradientOpacityFunction());
m_VtkDataSetMapper->SetLookupTable(transferFunction->GetColorTransferFunction());
m_VtkDataSetMapper2->SetLookupTable(transferFunction->GetColorTransferFunction());
}
bool isVolumeRenderingOn = false;
node->GetBoolProperty("volumerendering", isVolumeRenderingOn, renderer);
if (isVolumeRenderingOn)
{
m_Assembly->RemovePart(m_Actor);
m_Assembly->RemovePart(m_ActorWireframe);
m_Assembly->AddPart(m_Volume);
mitk::GridVolumeMapperProperty::Pointer mapperProp;
if (node->GetProperty(mapperProp, "volumerendering.mapper", renderer))
{
mitk::GridVolumeMapperProperty::IdType type = mapperProp->GetValueAsId();
switch (type) {
case mitk::GridVolumeMapperProperty::RAYCAST:
if (m_VtkVolumeRayCastMapper == 0) {
m_VtkVolumeRayCastMapper = vtkUnstructuredGridVolumeRayCastMapper::New();
m_VtkVolumeRayCastMapper->SetInputConnection(m_VtkTriangleFilter->GetOutputPort());
}
m_Volume->SetMapper(m_VtkVolumeRayCastMapper);
break;
case mitk::GridVolumeMapperProperty::PT:
if (m_VtkPTMapper == 0) {
m_VtkPTMapper = vtkProjectedTetrahedraMapper::New();
m_VtkPTMapper->SetInputConnection(m_VtkTriangleFilter->GetOutputPort());
}
m_Volume->SetMapper(m_VtkPTMapper);
break;
case mitk::GridVolumeMapperProperty::ZSWEEP:
if (m_VtkVolumeZSweepMapper == 0) {
m_VtkVolumeZSweepMapper = vtkUnstructuredGridVolumeZSweepMapper::New();
m_VtkVolumeZSweepMapper->SetInputConnection(m_VtkTriangleFilter->GetOutputPort());
}
m_Volume->SetMapper(m_VtkVolumeZSweepMapper);
break;
}
}
}
else
{
m_Assembly->RemovePart(m_Volume);
m_Assembly->AddPart(m_Actor);
m_Assembly->RemovePart(m_ActorWireframe);
mitk::GridRepresentationProperty::Pointer gridRepProp;
if (node->GetProperty(gridRepProp, "grid representation", renderer))
{
mitk::GridRepresentationProperty::IdType type = gridRepProp->GetValueAsId();
switch (type) {
case mitk::GridRepresentationProperty::POINTS:
property->SetRepresentationToPoints();
break;
case mitk::GridRepresentationProperty::WIREFRAME:
property->SetRepresentationToWireframe();
break;
case mitk::GridRepresentationProperty::SURFACE:
property->SetRepresentationToSurface();
break;
}
// if (type == mitk::GridRepresentationProperty::WIREFRAME_SURFACE)
// {
// m_Assembly->AddPart(m_ActorWireframe);
// }
}
}
// mitk::LevelWindow levelWindow;
// if(node->GetLevelWindow(levelWindow, renderer, "levelWindow"))
// {
// m_VtkVolumeRayCastMapper->SetScalarRange(levelWindow.GetMin(),levelWindow.GetMax());
// }
// else
// if(node->GetLevelWindow(levelWindow, renderer))
// {
// m_VtkVolumeRayCastMapper->SetScalarRange(levelWindow.GetMin(),levelWindow.GetMax());
// }
//
// mitk::VtkRepresentationProperty* representationProperty;
// node->GetProperty(representationProperty, "material.representation", renderer);
// if ( representationProperty != NULL )
// m_Volume->GetProperty()->SetRepresentation( representationProperty->GetVtkRepresentation() );
//
// mitk::VtkInterpolationProperty* interpolationProperty;
// node->GetProperty(interpolationProperty, "material.interpolation", renderer);
// if ( interpolationProperty != NULL )
// m_Volume->GetProperty()->SetInterpolation( interpolationProperty->GetVtkInterpolation() );
//
mitk::VtkScalarModeProperty* scalarMode = 0;
if(node->GetProperty(scalarMode, "scalar mode", renderer))
{
if (m_VtkVolumeRayCastMapper)
m_VtkVolumeRayCastMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
if (m_VtkPTMapper)
m_VtkPTMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
if (m_VtkVolumeZSweepMapper)
m_VtkVolumeZSweepMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
m_VtkDataSetMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
m_VtkDataSetMapper2->SetScalarMode(scalarMode->GetVtkScalarMode());
}
else
{
if (m_VtkVolumeRayCastMapper)
m_VtkVolumeRayCastMapper->SetScalarModeToDefault();
if (m_VtkPTMapper)
m_VtkPTMapper->SetScalarModeToDefault();
if (m_VtkVolumeZSweepMapper)
m_VtkVolumeZSweepMapper->SetScalarModeToDefault();
m_VtkDataSetMapper->SetScalarModeToDefault();
m_VtkDataSetMapper2->SetScalarModeToDefault();
}
bool scalarVisibility = true;
node->GetBoolProperty("scalar visibility", scalarVisibility, renderer);
m_VtkDataSetMapper->SetScalarVisibility(scalarVisibility ? 1 : 0);
m_VtkDataSetMapper2->SetScalarVisibility(scalarVisibility ? 1 : 0);
// double scalarRangeLower = std::numeric_limits<double>::min();
// double scalarRangeUpper = std::numeric_limits<double>::max();
// mitk::DoubleProperty* lowerRange = 0;
// if (node->GetProperty(lowerRange, "scalar range min", renderer))
// {
// scalarRangeLower = lowerRange->GetValue();
// }
// mitk::DoubleProperty* upperRange = 0;
// if (node->GetProperty(upperRange, "scalar range max", renderer))
// {
// scalarRangeUpper = upperRange->GetValue();
// }
// m_VtkDataSetMapper->SetScalarRange(scalarRangeLower, scalarRangeUpper);
// m_VtkDataSetMapper2->SetScalarRange(scalarRangeLower, scalarRangeUpper);
// bool colorMode = false;
// node->GetBoolProperty("color mode", colorMode);
// m_VtkVolumeRayCastMapper->SetColorMode( (colorMode ? 1 : 0) );
// double scalarsMin = 0;
// node->GetDoubleProperty("ScalarsRangeMinimum", scalarsMin, renderer);
// double scalarsMax = 1.0;
// node->GetProperty("ScalarsRangeMaximum", scalarsMax, renderer);
// m_VtkVolumeRayCastMapper->SetScalarRange(scalarsMin,scalarsMax);
}
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::UnstructuredGridMapper2D::Paint( mitk::BaseRenderer* renderer )
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if(!visible) return;
vtkLinearTransform * vtktransform = GetDataNode()->GetVtkTransform();
vtkLinearTransform * inversetransform = vtktransform->GetLinearInverse();
PlaneGeometry::ConstPointer worldGeometry = renderer->GetCurrentWorldPlaneGeometry();
PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );
Point3D point;
Vector3D normal;
if(worldPlaneGeometry.IsNotNull())
{
// set up vtkPlane according to worldGeometry
point=worldPlaneGeometry->GetOrigin();
normal=worldPlaneGeometry->GetNormal(); normal.Normalize();
m_Plane->SetTransform((vtkAbstractTransform*)NULL);
}
else
{
//@FIXME: does not work correctly. Does m_Plane->SetTransform really transforms a "plane plane" into a "curved plane"?
return;
AbstractTransformGeometry::ConstPointer worldAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(renderer->GetCurrentWorldPlaneGeometry());
if(worldAbstractGeometry.IsNotNull())
{
// set up vtkPlane according to worldGeometry
point=const_cast<mitk::BoundingBox*>(worldAbstractGeometry->GetParametricBoundingBox())->GetMinimum();
FillVector3D(normal, 0, 0, 1);
m_Plane->SetTransform(worldAbstractGeometry->GetVtkAbstractTransform()->GetInverse());
}
else
return;
}
double vp[ 3 ], vnormal[ 3 ];
vnl2vtk(point.GetVnlVector(), vp);
vnl2vtk(normal.GetVnlVector(), vnormal);
//normally, we would need to transform the surface and cut the transformed surface with the cutter.
//This might be quite slow. Thus, the idea is, to perform an inverse transform of the plane instead.
//@todo It probably does not work for scaling operations yet:scaling operations have to be
//dealed with after the cut is performed by scaling the contour.
inversetransform->TransformPoint( vp, vp );
inversetransform->TransformNormalAtPoint( vp, vnormal, vnormal );
m_Plane->SetOrigin( vp );
m_Plane->SetNormal( vnormal );
// set data into cutter
m_Slicer->SetInputData( m_VtkPointSet );
// m_Cutter->GenerateCutScalarsOff();
// m_Cutter->SetSortByToSortByCell();
// calculate the cut
m_Slicer->Update();
//apply color and opacity read from the PropertyList
ApplyColorAndOpacityProperties( renderer );
// traverse the cut contour
vtkPolyData * contour = m_Slicer->GetOutput();
vtkPoints *vpoints = contour->GetPoints();
vtkCellArray *vlines = contour->GetLines();
vtkCellArray *vpolys = contour->GetPolys();
vtkPointData *vpointdata = contour->GetPointData();
vtkDataArray* vscalars = vpointdata->GetScalars();
vtkCellData *vcelldata = contour->GetCellData();
vtkDataArray* vcellscalars = vcelldata->GetScalars();
const int numberOfLines = contour->GetNumberOfLines();
const int numberOfPolys = contour->GetNumberOfPolys();
const bool useCellData = m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_DEFAULT ||
m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_CELL_DATA;
const bool usePointData = m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_POINT_DATA;
Point3D p;
Point2D p2d;
vlines->InitTraversal();
vpolys->InitTraversal();
mitk::Color outlineColor = m_Color->GetColor();
glLineWidth((float)m_LineWidth->GetValue());
for (int i = 0;i < numberOfLines;++i )
{
vtkIdType *cell(0);
vtkIdType cellSize(0);
vlines->GetNextCell( cellSize, cell );
float rgba[4] = {outlineColor[0], outlineColor[1], outlineColor[2], 1.0f};
if (m_ScalarVisibility->GetValue() && vcellscalars)
{
if ( useCellData )
{ // color each cell according to cell data
double scalar = vcellscalars->GetComponent( i, 0 );
double rgb[3] = { 1.0f, 1.0f, 1.0f };
m_ScalarsToColors->GetColor(scalar, rgb);
rgba[0] = (float)rgb[0];
rgba[1] = (float)rgb[1];
rgba[2] = (float)rgb[2];
rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
}
else if ( usePointData )
{
double scalar = vscalars->GetComponent( i, 0 );
double rgb[3] = { 1.0f, 1.0f, 1.0f };
m_ScalarsToColors->GetColor(scalar, rgb);
rgba[0] = (float)rgb[0];
rgba[1] = (float)rgb[1];
rgba[2] = (float)rgb[2];
rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
}
}
glColor4fv( rgba );
glBegin ( GL_LINE_LOOP );
for ( int j = 0;j < cellSize;++j )
{
vpoints->GetPoint( cell[ j ], vp );
//take transformation via vtktransform into account
vtktransform->TransformPoint( vp, vp );
vtk2itk( vp, p );
//convert 3D point (in mm) to display coordinates (units )
renderer->WorldToDisplay( p, p2d );
//convert display coordinates ( (0,0) is top-left ) in GL coordinates ( (0,0) is bottom-left )
//p2d[1]=toGL-p2d[1];
//add the current vertex to the line
glVertex2f( p2d[0], p2d[1] );
}
glEnd ();
}
bool polyOutline = m_Outline->GetValue();
bool scalarVisibility = m_ScalarVisibility->GetValue();
// cache the transformed points
// a fixed size array is way faster than 'new'
// slices through 3d cells usually do not generated
// polygons with more than 6 vertices
const int maxPolySize = 10;
Point2D* cachedPoints = new Point2D[maxPolySize*numberOfPolys];
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// only draw polygons if there are cell scalars
// or the outline property is set to true
if (scalarVisibility && vcellscalars)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
for (int i = 0;i < numberOfPolys;++i )
{
vtkIdType *cell(0);
vtkIdType cellSize(0);
vpolys->GetNextCell( cellSize, cell );
float rgba[4] = {1.0f, 1.0f, 1.0f, 0};
if (scalarVisibility && vcellscalars)
{
if ( useCellData )
{ // color each cell according to cell data
double scalar = vcellscalars->GetComponent( i+numberOfLines, 0 );
double rgb[3] = { 1.0f, 1.0f, 1.0f };
m_ScalarsToColors->GetColor(scalar, rgb);
rgba[0] = (float)rgb[0];
rgba[1] = (float)rgb[1];
rgba[2] = (float)rgb[2];
rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
}
else if ( usePointData )
{
double scalar = vscalars->GetComponent( i, 0 );
double rgb[3] = { 1.0f, 1.0f, 1.0f };
m_ScalarsToColors->GetColor(scalar, rgb);
rgba[0] = (float)rgb[0];
rgba[1] = (float)rgb[1];
rgba[2] = (float)rgb[2];
rgba[3] = (float)m_ScalarsToOpacity->GetValue(scalar);
}
}
glColor4fv( rgba );
glBegin( GL_POLYGON );
for (int j = 0; j < cellSize; ++j)
{
vpoints->GetPoint( cell[ j ], vp );
//take transformation via vtktransform into account
vtktransform->TransformPoint( vp, vp );
vtk2itk( vp, p );
//convert 3D point (in mm) to display coordinates (units )
renderer->WorldToDisplay( p, p2d );
//convert display coordinates ( (0,0) is top-left ) in GL coordinates ( (0,0) is bottom-left )
//p2d[1]=toGL-p2d[1];
cachedPoints[i*10+j][0] = p2d[0];
cachedPoints[i*10+j][1] = p2d[1];
//add the current vertex to the line
glVertex2f( p2d[0], p2d[1] );
}
glEnd();
}
if (polyOutline)
{
vpolys->InitTraversal();
glColor4f(outlineColor[0], outlineColor[1], outlineColor[2], 1.0f);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
for (int i = 0;i < numberOfPolys;++i)
{
vtkIdType *cell(0);
vtkIdType cellSize(0);
vpolys->GetNextCell( cellSize, cell );
glBegin( GL_POLYGON );
//glPolygonOffset(1.0, 1.0);
for (int j = 0; j < cellSize; ++j)
{
//add the current vertex to the line
glVertex2f( cachedPoints[i*10+j][0], cachedPoints[i*10+j][1] );
}
glEnd();
}
}
}
glDisable(GL_BLEND);
delete[] cachedPoints;
}
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++;
}
}
}
void mitk::ContourMapper2D::MitkRender(mitk::BaseRenderer *renderer, mitk::VtkPropRenderer::RenderType /*type*/)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if (!visible)
return;
//// @FIXME: Logik fuer update
bool updateNeccesary = true;
if (updateNeccesary)
{
mitk::Contour::Pointer input = const_cast<mitk::Contour *>(this->GetInput());
// apply color and opacity read from the PropertyList
ApplyColorAndOpacityProperties(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")) != nullptr)
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);
renderer->GetCurrentWorldPlaneGeometry()->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;
renderer->WorldToDisplay(p, pt2d);
glVertex2f(pt2d[0], pt2d[1]);
}
pointsIt++;
// idx += 1;
}
glEnd();
glLineWidth(1.0);
}
}
