diff --git a/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp b/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp
index 66af171c05..59e72c801c 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp
+++ b/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp
@@ -1,396 +1,396 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkContourModelSetGLMapper2D.h"
#include "mitkColorProperty.h"
#include "mitkContourModelSet.h"
#include "mitkPlaneGeometry.h"
#include "mitkProperties.h"
#include <vtkLinearTransform.h>
#include "mitkGL.h"
mitk::ContourModelSetGLMapper2D::ContourModelSetGLMapper2D()
{
}
mitk::ContourModelSetGLMapper2D::~ContourModelSetGLMapper2D()
{
}
void mitk::ContourModelSetGLMapper2D::Paint(mitk::BaseRenderer *renderer)
{
BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
mitk::DataNode *dataNode = this->GetDataNode();
bool visible = true;
dataNode->GetVisibility(visible, nullptr);
if (!visible)
return;
mitk::ContourModelSet *input = this->GetInput();
auto centerOfViewPointZ = renderer->GetCurrentWorldPlaneGeometry()->GetCenter()[2];
mitk::ContourModelSet::ContourModelSetIterator it = input->Begin();
mitk::ContourModelSet::ContourModelSetIterator end = input->End();
while (it != end)
{
//we have the assumption that each contour model vertex has the same z coordinate
auto currentZValue = (*it)->GetVertexAt(0)->Coordinates[2];
double acceptedDeviationInMM = 5.0;
//only draw contour if it is visible
if (currentZValue - acceptedDeviationInMM < centerOfViewPointZ && currentZValue + acceptedDeviationInMM > centerOfViewPointZ){
this->DrawContour(it->GetPointer(), renderer);
}
++it;
}
if (input->GetSize() < 1)
return;
ls->UpdateGenerateDataTime();
}
mitk::ContourModelSet *mitk::ContourModelSetGLMapper2D::GetInput(void)
{
return const_cast<mitk::ContourModelSet *>(static_cast<const mitk::ContourModelSet *>(GetDataNode()->GetData()));
}
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
+ // draw control 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::ContourModelSetGLMapper2D::SetDefaultProperties(mitk::DataNode *node,
mitk::BaseRenderer *renderer,
bool overwrite)
{
node->AddProperty("contour.color", ColorProperty::New(0.9, 1.0, 0.1), renderer, overwrite);
node->AddProperty("contour.points.color", ColorProperty::New(1.0, 0.0, 0.1), renderer, overwrite);
node->AddProperty("contour.points.show", mitk::BoolProperty::New(false), renderer, overwrite);
node->AddProperty("contour.segments.show", mitk::BoolProperty::New(true), renderer, overwrite);
node->AddProperty("contour.controlpoints.show", mitk::BoolProperty::New(false), renderer, overwrite);
node->AddProperty("contour.width", mitk::FloatProperty::New(1.0), renderer, overwrite);
node->AddProperty("contour.hovering.width", mitk::FloatProperty::New(3.0), renderer, overwrite);
node->AddProperty("contour.hovering", mitk::BoolProperty::New(false), renderer, overwrite);
node->AddProperty("contour.points.text", mitk::BoolProperty::New(false), renderer, overwrite);
node->AddProperty("contour.controlpoints.text", mitk::BoolProperty::New(false), renderer, overwrite);
node->AddProperty("contour.project-onto-plane", mitk::BoolProperty::New(false), renderer, overwrite);
node->AddProperty("opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite);
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
diff --git a/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.h b/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.h
index 53279d9919..cc3e919507 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.h
+++ b/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.h
@@ -1,70 +1,70 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef MITK_ContourModelSetGLMapper2D_H_
#define MITK_ContourModelSetGLMapper2D_H_
#include "mitkBaseRenderer.h"
#include "mitkCommon.h"
#include "mitkContourModelGLMapper2DBase.h"
#include "mitkContourModelSet.h"
#include <MitkContourModelExports.h>
namespace mitk
{
class BaseRenderer;
class ContourModel;
/**
* @brief OpenGL-based mapper to display a mitk::ContourModelSet object containing several contours in a 2D render
* window
*
*
* @ingroup MitkContourModelModule
*/
class MITKCONTOURMODEL_EXPORT ContourModelSetGLMapper2D : public ContourModelGLMapper2DBase
{
public:
mitkClassMacro(ContourModelSetGLMapper2D, ContourModelGLMapper2DBase);
itkFactorylessNewMacro(Self) itkCloneMacro(Self)
/**
* reimplemented from Baseclass
*/
virtual void Paint(BaseRenderer *renderer) override;
static void SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer = NULL, bool overwrite = false);
LocalStorageHandler<BaseLocalStorage> m_LSH;
protected:
ContourModelSetGLMapper2D();
virtual ~ContourModelSetGLMapper2D();
void InternalDrawContour(mitk::ContourModel *contour, mitk::BaseRenderer *renderer) override;
private:
/**
- * return a refernce of the rendered data object
+ * return a reference of the rendered data object
*/
ContourModelSet *GetInput(void);
};
} // namespace mitk
#endif
diff --git a/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp b/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp
index ef3bc6282d..b8c6745739 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp
+++ b/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp
@@ -1,236 +1,236 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkContourModelSetMapper3D.h>
#include "mitkSurface.h"
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
#include <vtkProperty.h>
mitk::ContourModelSetMapper3D::ContourModelSetMapper3D()
{
}
mitk::ContourModelSetMapper3D::~ContourModelSetMapper3D()
{
}
const mitk::ContourModelSet *mitk::ContourModelSetMapper3D::GetInput(void)
{
- // convient way to get the data from the dataNode
+ // convenient way to get the data from the dataNode
return static_cast<const mitk::ContourModelSet *>(GetDataNode()->GetData());
}
vtkProp *mitk::ContourModelSetMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
{
// return the actor corresponding to the renderer
return m_LSH.GetLocalStorage(renderer)->m_Assembly;
}
void mitk::ContourModelSetMapper3D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
{
/* First convert the contourModel to vtkPolyData, then tube filter it and
* set it input for our mapper
*/
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
ContourModelSet *contourModelSet = dynamic_cast<ContourModelSet *>(this->GetDataNode()->GetData());
if (contourModelSet != NULL)
{
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
vtkIdType baseIndex = 0;
ContourModelSet::ContourModelSetIterator it = contourModelSet->Begin();
ContourModelSet::ContourModelSetIterator end = contourModelSet->End();
while (it != end)
{
ContourModel *contourModel = it->GetPointer();
ContourModel::VertexIterator vertIt = contourModel->Begin();
ContourModel::VertexIterator vertEnd = contourModel->End();
while (vertIt != vertEnd)
{
points->InsertNextPoint((*vertIt)->Coordinates[0], (*vertIt)->Coordinates[1], (*vertIt)->Coordinates[2]);
++vertIt;
}
vtkSmartPointer<vtkPolyLine> line = vtkSmartPointer<vtkPolyLine>::New();
vtkIdList *pointIds = line->GetPointIds();
vtkIdType numPoints = contourModel->GetNumberOfVertices();
pointIds->SetNumberOfIds(numPoints + 1);
for (vtkIdType i = 0; i < numPoints; ++i)
pointIds->SetId(i, baseIndex + i);
pointIds->SetId(numPoints, baseIndex);
cells->InsertNextCell(line);
baseIndex += numPoints;
++it;
}
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
polyData->SetPoints(points);
polyData->SetLines(cells);
vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
actor->SetMapper(mapper);
mapper->SetInputData(polyData);
localStorage->m_Assembly->AddPart(actor);
}
this->ApplyContourProperties(renderer);
this->ApplyContourModelSetProperties(renderer);
}
void mitk::ContourModelSetMapper3D::Update(mitk::BaseRenderer *renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
mitk::ContourModel *data = static_cast<mitk::ContourModel *>(GetDataNode()->GetData());
if (data == NULL)
{
return;
}
// Calculate time step of the input data for the specified renderer (integer value)
this->CalculateTimeStep(renderer);
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
if (this->GetTimestep() == -1)
{
return;
}
const DataNode *node = this->GetDataNode();
data->UpdateOutputInformation();
// check if something important has changed and we need to rerender
if ((localStorage->m_LastUpdateTime < node->GetMTime()) // was the node modified?
||
(localStorage->m_LastUpdateTime < data->GetPipelineMTime()) // Was the data modified?
||
(localStorage->m_LastUpdateTime <
renderer->GetCurrentWorldPlaneGeometryUpdateTime()) // was the geometry modified?
||
(localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime()) ||
(localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) // was a property modified?
||
(localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()))
{
this->GenerateDataForRenderer(renderer);
}
// since we have checked that nothing important has changed, we can set
// m_LastUpdateTime to the current time
localStorage->m_LastUpdateTime.Modified();
}
vtkSmartPointer<vtkPolyData> mitk::ContourModelSetMapper3D::CreateVtkPolyDataFromContour(
mitk::ContourModel *inputContour, mitk::BaseRenderer *renderer)
{
unsigned int timestep = this->GetTimestep();
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
localStorage->m_contourToPolyData->SetInput(inputContour);
localStorage->m_contourToPolyData->Update();
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
polyData = localStorage->m_contourToPolyData->GetOutput()->GetVtkPolyData(timestep);
return polyData;
}
void mitk::ContourModelSetMapper3D::ApplyContourModelSetProperties(BaseRenderer *renderer)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
DataNode *dataNode = this->GetDataNode();
if (dataNode != NULL)
{
float lineWidth = 1;
dataNode->GetFloatProperty("contour.3D.width", lineWidth, renderer);
vtkSmartPointer<vtkPropCollection> collection = vtkSmartPointer<vtkPropCollection>::New();
localStorage->m_Assembly->GetActors(collection);
collection->InitTraversal();
for (vtkIdType i = 0; i < collection->GetNumberOfItems(); i++)
{
vtkActor::SafeDownCast(collection->GetNextProp())->GetProperty()->SetLineWidth(lineWidth);
}
}
}
void mitk::ContourModelSetMapper3D::ApplyContourProperties(mitk::BaseRenderer *renderer)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
mitk::ColorProperty::Pointer colorprop =
dynamic_cast<mitk::ColorProperty *>(GetDataNode()->GetProperty("contour.color", renderer));
if (colorprop)
{
// set the color of the contour
double red = colorprop->GetColor().GetRed();
double green = colorprop->GetColor().GetGreen();
double blue = colorprop->GetColor().GetBlue();
vtkSmartPointer<vtkPropCollection> collection = vtkSmartPointer<vtkPropCollection>::New();
localStorage->m_Assembly->GetActors(collection);
collection->InitTraversal();
for (vtkIdType i = 0; i < collection->GetNumberOfItems(); i++)
{
vtkActor::SafeDownCast(collection->GetNextProp())->GetProperty()->SetColor(red, green, blue);
}
}
}
/*+++++++++++++++++++ LocalStorage part +++++++++++++++++++++++++*/
mitk::ContourModelSetMapper3D::LocalStorage *mitk::ContourModelSetMapper3D::GetLocalStorage(
mitk::BaseRenderer *renderer)
{
return m_LSH.GetLocalStorage(renderer);
}
mitk::ContourModelSetMapper3D::LocalStorage::LocalStorage()
{
m_Assembly = vtkSmartPointer<vtkAssembly>::New();
m_contourToPolyData = mitk::ContourModelToSurfaceFilter::New();
}
void mitk::ContourModelSetMapper3D::SetDefaultProperties(mitk::DataNode *node,
mitk::BaseRenderer *renderer,
bool overwrite)
{
node->AddProperty("color", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite);
node->AddProperty("contour.3D.width", mitk::FloatProperty::New(0.5), renderer, overwrite);
Superclass::SetDefaultProperties(node, renderer, overwrite);
}