diff --git a/Core/Code/Resources/Interactions/Legacy/StateMachine.xml b/Core/Code/Resources/Interactions/Legacy/StateMachine.xml
index dad32c7bb8..ad04e9f044 100644
--- a/Core/Code/Resources/Interactions/Legacy/StateMachine.xml
+++ b/Core/Code/Resources/Interactions/Legacy/StateMachine.xml
@@ -1,4103 +1,4103 @@
-
-
+
+
diff --git a/Modules/Segmentation/Interactions/mitkContourModelInteractor.cpp b/Modules/Segmentation/Interactions/mitkContourModelInteractor.cpp
index 124d44427f..168e1046c8 100644
--- a/Modules/Segmentation/Interactions/mitkContourModelInteractor.cpp
+++ b/Modules/Segmentation/Interactions/mitkContourModelInteractor.cpp
@@ -1,295 +1,285 @@
/*===================================================================
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 "mitkContourModelInteractor.h"
#include "mitkToolManager.h"
#include "mitkBaseRenderer.h"
#include "mitkRenderingManager.h"
#include
#include
#include
mitk::ContourModelInteractor::ContourModelInteractor(DataNode* dataNode)
:Interactor("ContourModelInteractor", dataNode)
{
CONNECT_ACTION( AcCHECKPOINT, OnCheckPointClick );
CONNECT_ACTION( AcCHECKOBJECT, OnCheckContourClick );
CONNECT_ACTION( AcDELETEPOINT, OnDeletePoint );
CONNECT_ACTION( AcMOVEPOINT, OnMovePoint );
// CONNECT_ACTION( AcMOVE, OnMoveContour );
CONNECT_ACTION( AcMOVE, OnMove );
CONNECT_ACTION( AcFINISH, OnFinish );
}
mitk::ContourModelInteractor::~ContourModelInteractor()
{
}
float mitk::ContourModelInteractor::CanHandleEvent(StateEvent const* stateEvent) const
{
float returnValue = 0.0;
//if it is a key event that can be handled in the current state, then return 0.5
mitk::PositionEvent const *positionEvent =
dynamic_cast (stateEvent->GetEvent());
//Key event handling:
if (positionEvent == NULL)
{
//check for delete and escape event
if(stateEvent->GetId() == 12 || stateEvent->GetId() == 14)
{
return 1.0;
}
//check, if the current state has a transition waiting for that key event.
else if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
{
return 0.5;
}
else
{
return 0;
}
}
int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
mitk::ContourModel *contour = dynamic_cast(
m_DataNode->GetData() );
if ( contour != NULL )
{
mitk::Point3D worldPoint3D = positionEvent->GetWorldPosition();
mitk::Geometry3D *contourGeometry =
dynamic_cast< Geometry3D * >( contour->GetGeometry( timestep ) );
if ( contourGeometry )
{
//if click is inside bounds the interactor can handle the event best
if( contourGeometry->IsInside(worldPoint3D) )
{
return 1.0;
}
return 0.9;
}
}
return returnValue;
}
void mitk::ContourModelInteractor::DataChanged()
{
//go to initial state
const mitk::Event* nullEvent = new mitk::Event(NULL, Type_User, BS_NoButton, BS_NoButton, Key_none);
mitk::StateEvent* newStateEvent = new mitk::StateEvent(AcFINISH, nullEvent);
this->HandleEvent( newStateEvent );
delete newStateEvent;
delete nullEvent;
return;
}
bool mitk::ContourModelInteractor::OnCheckPointClick( Action* action, const StateEvent* stateEvent)
{
const PositionEvent* positionEvent = dynamic_cast(stateEvent->GetEvent());
if (!positionEvent) return false;
mitk::StateEvent* newStateEvent = NULL;
int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
mitk::ContourModel *contour = dynamic_cast(
m_DataNode->GetData() );
-
contour->Deselect();
/*
* Check distance to any vertex.
* Transition YES if click close to a vertex
*/
mitk::Point3D click = positionEvent->GetWorldPosition();
if (contour->SelectVertexAt(click, 1.5, timestep) )
{
contour->SetSelectedVertexAsControlPoint();
assert( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
newStateEvent = new mitk::StateEvent(EIDYES, stateEvent->GetEvent());
m_lastMousePosition = click;
}
else
{
newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
}
this->HandleEvent( newStateEvent );
return true;
}
bool mitk::ContourModelInteractor::OnCheckContourClick( Action* action, const StateEvent* stateEvent)
{
const PositionEvent* positionEvent = dynamic_cast(stateEvent->GetEvent());
if (!positionEvent) return false;
int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
mitk::Point3D click = positionEvent->GetWorldPosition();
mitk::StateEvent* newStateEvent = NULL;
mitk::ContourModel *contour = dynamic_cast(
m_DataNode->GetData() );
mitk::Geometry3D *contourGeometry = dynamic_cast< Geometry3D * >( contour->GetGeometry( timestep ) );
if ( contourGeometry->IsInside(click) )
{
m_lastMousePosition = click;
newStateEvent = new mitk::StateEvent(EIDYES, stateEvent->GetEvent());
}
else
{
newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
}
this->HandleEvent( newStateEvent );
return true;
}
bool mitk::ContourModelInteractor::OnDeletePoint( Action* action, const StateEvent* stateEvent)
{
int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
mitk::ContourModel *contour = dynamic_cast( m_DataNode->GetData() );
contour->RemoveVertex(contour->GetSelectedVertex());
return true;
}
bool mitk::ContourModelInteractor::OnMove( Action* action, const StateEvent* stateEvent)
{
const PositionEvent* positionEvent = dynamic_cast(stateEvent->GetEvent());
if (!positionEvent) return false;
int timestep = positionEvent->GetSender()->GetTimeStep();
mitk::ContourModel *contour = dynamic_cast( m_DataNode->GetData() );
mitk::Point3D currentPosition = positionEvent->GetWorldPosition();
- if (contour->IsNearContour(currentPosition, 1.5, timestep))
- {
- m_DataNode->SetFloatProperty("contour.width", 4.0 );
- m_DataNode->SetProperty("contour.color", ColorProperty::New(1,0,0));
- }
- else
- {
- m_DataNode->SetFloatProperty("contour.width", 2.0 );
- m_DataNode->SetProperty("contour.color", ColorProperty::New(0,0,1));
- }
+ m_DataNode->SetBoolProperty("contour.hovering", contour->IsNearContour(currentPosition, 1.5, timestep) );
assert( positionEvent->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
return true;
}
bool mitk::ContourModelInteractor::OnMovePoint( Action* action, const StateEvent* stateEvent)
{
const PositionEvent* positionEvent = dynamic_cast(stateEvent->GetEvent());
if (!positionEvent) return false;
-
mitk::ContourModel *contour = dynamic_cast( m_DataNode->GetData() );
mitk::Vector3D translation;
mitk::Point3D currentPosition = positionEvent->GetWorldPosition();
translation[0] = currentPosition[0] - this->m_lastMousePosition[0];
translation[1] = currentPosition[1] - this->m_lastMousePosition[1];
translation[2] = currentPosition[2] - this->m_lastMousePosition[2];
contour->ShiftSelectedVertex(translation);
this->m_lastMousePosition = positionEvent->GetWorldPosition();
assert( positionEvent->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
return true;
}
bool mitk::ContourModelInteractor::OnMoveContour( Action* action, const StateEvent* stateEvent)
{
const PositionEvent* positionEvent = dynamic_cast(stateEvent->GetEvent());
if (!positionEvent) return false;
int timestep = positionEvent->GetSender()->GetTimeStep();
mitk::ContourModel *contour = dynamic_cast( m_DataNode->GetData() );
mitk::Vector3D translation;
mitk::Point3D currentPosition = positionEvent->GetWorldPosition();
translation[0] = currentPosition[0] - this->m_lastMousePosition[0];
translation[1] = currentPosition[1] - this->m_lastMousePosition[1];
translation[2] = currentPosition[2] - this->m_lastMousePosition[2];
contour->ShiftContour(translation, timestep);
this->m_lastMousePosition = positionEvent->GetWorldPosition();
assert( positionEvent->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
return true;
}
bool mitk::ContourModelInteractor::OnFinish( Action* action, const StateEvent* stateEvent)
{
+ m_DataNode->SetBoolProperty( "contour.editing", false );
mitk::ContourModel *contour = dynamic_cast( m_DataNode->GetData() );
contour->Deselect();
assert( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
return true;
}
diff --git a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
index 71fdceeff9..e8d9f5e3b5 100644
--- a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
+++ b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
@@ -1,349 +1,350 @@
/*===================================================================
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 "mitkContourModelLiveWireInteractor.h"
#include "mitkToolManager.h"
#include "mitkBaseRenderer.h"
#include "mitkRenderingManager.h"
#include
#include
#include
mitk::ContourModelLiveWireInteractor::ContourModelLiveWireInteractor(DataNode* dataNode)
:ContourModelInteractor(dataNode)
{
m_LiveWireFilter = mitk::ImageLiveWireContourModelFilter::New();
mitk::ContourModel::Pointer m_ContourLeft = mitk::ContourModel::New();
mitk::ContourModel::Pointer m_ContourRight = mitk::ContourModel::New();
m_NextActiveVertexDown.Fill(0);
m_NextActiveVertexUp.Fill(0);
}
mitk::ContourModelLiveWireInteractor::~ContourModelLiveWireInteractor()
{
}
bool mitk::ContourModelLiveWireInteractor::OnCheckPointClick( Action* action, const StateEvent* stateEvent)
{
const PositionEvent* positionEvent = dynamic_cast(stateEvent->GetEvent());
if (!positionEvent) {
this->HandleEvent( new mitk::StateEvent(EIDNO, stateEvent->GetEvent()) );
return false;
}
-
-
mitk::StateEvent* newStateEvent = NULL;
int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
mitk::ContourModel *contour = dynamic_cast(
m_DataNode->GetData() );
contour->Deselect();
/*
* Check distance to any vertex.
* Transition YES if click close to a vertex
*/
mitk::Point3D click = positionEvent->GetWorldPosition();
if (contour->SelectVertexAt(click, 1.5, timestep) )
{
contour->SetSelectedVertexAsControlPoint();
+ m_DataNode->SetBoolProperty( "contour.editing", true );
+
assert( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
newStateEvent = new mitk::StateEvent(EIDYES, stateEvent->GetEvent());
m_lastMousePosition = click;
mitk::ContourModel *contour = dynamic_cast( m_DataNode->GetData() );
//
m_ContourLeft = mitk::ContourModel::New();
//get coordinates of next active vertex downwards from selected vertex
int downIndex = SplitContourFromSelectedVertex( contour, m_ContourLeft, false, timestep);
mitk::ContourModel::VertexIterator itDown = contour->IteratorBegin() + downIndex;
m_NextActiveVertexDown = (*itDown)->Coordinates;
//
m_ContourRight = mitk::ContourModel::New();
//get coordinates of next active vertex upwards from selected vertex
int upIndex = SplitContourFromSelectedVertex( contour, m_ContourRight, true, timestep);
mitk::ContourModel::VertexIterator itUp = contour->IteratorBegin() + upIndex;
m_NextActiveVertexUp = (*itUp)->Coordinates;
}
else
{
+ m_DataNode->SetBoolProperty( "contour.editing", false );
newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
}
this->HandleEvent( newStateEvent );
return true;
}
bool mitk::ContourModelLiveWireInteractor::OnDeletePoint( Action* action, const StateEvent* stateEvent)
{
int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
mitk::ContourModel *contour = dynamic_cast( m_DataNode->GetData() );
if(contour->GetSelectedVertex())
{
mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
newContour->Expand(contour->GetTimeSteps());
newContour->Concatenate( m_ContourLeft, timestep );
//recompute contour between neighbored two active control points
this->m_LiveWireFilter->SetStartPoint( m_NextActiveVertexDown );
this->m_LiveWireFilter->SetEndPoint( m_NextActiveVertexUp );
this->m_LiveWireFilter->Update();
mitk::ContourModel::Pointer liveWireContour = mitk::ContourModel::New();
liveWireContour = this->m_LiveWireFilter->GetOutput();
//insert new liveWire computed points
newContour->Concatenate( liveWireContour, timestep );
newContour->Concatenate( m_ContourRight, timestep );
newContour->SetIsClosed(contour->IsClosed(timestep), timestep);
m_DataNode->SetData(newContour);
assert( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
}
return true;
}
bool mitk::ContourModelLiveWireInteractor::OnMovePoint( Action* action, const StateEvent* stateEvent)
{
const PositionEvent* positionEvent = dynamic_cast(stateEvent->GetEvent());
if (!positionEvent) return false;
int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
mitk::ContourModel *contour = dynamic_cast( m_DataNode->GetData() );
mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
newContour->Expand(contour->GetTimeSteps());
/*++++++++++++++ concatenate LEFT ++++++++++++++++++++++++++++++*/
newContour->Concatenate( m_ContourLeft, timestep );
mitk::Point3D currentPosition = positionEvent->GetWorldPosition();
/*+++++++++++++++ start computation ++++++++++++++++++++*/
//recompute contour between previous active vertex and selected vertex
this->m_LiveWireFilter->SetStartPoint( m_NextActiveVertexDown );
this->m_LiveWireFilter->SetEndPoint( currentPosition );
this->m_LiveWireFilter->Update();
mitk::ContourModel::Pointer liveWireContour = mitk::ContourModel::New();
liveWireContour = this->m_LiveWireFilter->GetOutput();
//remove point at current position because it is included in next livewire segment too.
liveWireContour->RemoveVertexAt( liveWireContour->GetNumberOfVertices(timestep) - 1, timestep);
/*++++++++++++++ concatenate LIVEWIRE ++++++++++++++++++++++++++++++*/
//insert new liveWire computed points
newContour->Concatenate( liveWireContour, timestep );
//recompute contour between selected vertex and next active vertex
this->m_LiveWireFilter->SetStartPoint( currentPosition );
this->m_LiveWireFilter->SetEndPoint( m_NextActiveVertexUp );
this->m_LiveWireFilter->Update();
liveWireContour = this->m_LiveWireFilter->GetOutput();
//make point at mouse position active again, so it is drawn
const_cast( liveWireContour->GetVertexAt(0, timestep) )->IsControlPoint = true;
/*++++++++++++++ concatenate RIGHT ++++++++++++++++++++++++++++++*/
//insert new liveWire computed points
newContour->Concatenate( liveWireContour, timestep );
/*------------------------------------------------*/
newContour->Concatenate( m_ContourRight, timestep );
newContour->SetIsClosed(contour->IsClosed(timestep), timestep);
newContour->Deselect();//just to make sure
m_DataNode->SetData(newContour);
this->m_lastMousePosition = positionEvent->GetWorldPosition();
assert( positionEvent->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
return true;
}
int mitk::ContourModelLiveWireInteractor::SplitContourFromSelectedVertex(mitk::ContourModel* sourceContour, mitk::ContourModel* destinationContour, bool fromSelectedUpwards, int timestep)
{
mitk::ContourModel::VertexIterator end =sourceContour->IteratorEnd();
mitk::ContourModel::VertexIterator begin =sourceContour->IteratorBegin();
//search next active control point to left and rigth and set as start and end point for filter
mitk::ContourModel::VertexIterator itSelected = sourceContour->IteratorBegin();
//move iterator to position
while((*itSelected) != sourceContour->GetSelectedVertex())
{
itSelected++;
}
//CASE search upwards for next control point
if(fromSelectedUpwards)
{
mitk::ContourModel::VertexIterator itUp = itSelected;
if(itUp != end)
{
itUp++;//step once up otherwise the the loop breaks immediately
}
while( itUp != end && !((*itUp)->IsControlPoint)){ itUp++; }
mitk::ContourModel::VertexIterator it = itUp;
if(itSelected != begin)
{
//copy the rest of the original contour
while(it != end)
{
destinationContour->AddVertex( (*it)->Coordinates, (*it)->IsControlPoint, timestep);
it++;
}
}
//else do not copy the contour
//return the offset of iterator at one before next-vertex-upwards
if(itUp != begin)
{
return std::distance( begin, itUp) - 1;
}
else
{
return std::distance( begin, itUp);
}
}
else //CASE search downwards for next control point
{
mitk::ContourModel::VertexIterator itDown = itSelected;
mitk::ContourModel::VertexIterator it = sourceContour->IteratorBegin();
if( itSelected != begin )
{
if(itDown != begin)
{
itDown--;//step once down otherwise the the loop breaks immediately
}
while( itDown != begin && !((*itDown)->IsControlPoint)){ itDown--; }
if(it != end)//if not empty
{
//always add the first vertex
destinationContour->AddVertex( (*it)->Coordinates, (*it)->IsControlPoint, timestep);
it++;
}
//copy from begin to itDown
while(it <= itDown)
{
destinationContour->AddVertex( (*it)->Coordinates, (*it)->IsControlPoint, timestep);
it++;
}
}
else
{
//if selected vertex is the first element search from end of contour downwards
itDown = end;
itDown--;
while(!((*itDown)->IsControlPoint)){itDown--;}
//move one forward as we don't want the first control point
it++;
//move iterator to second control point
while( (it!=end) && !((*it)->IsControlPoint) ){it++;}
//copy from begin to itDown
while(it <= itDown)
{
//copy the contour from second control point to itDown
destinationContour->AddVertex( (*it)->Coordinates, (*it)->IsControlPoint, timestep);
it++;
}
}
//add vertex at itDown - it's not considered during while loop
if( it != begin && it != end)
{
//destinationContour->AddVertex( (*it)->Coordinates, (*it)->IsControlPoint, timestep);
}
//return the offset of iterator at one after next-vertex-downwards
if( itDown != end)
{
return std::distance( begin, itDown);// + 1;//index of next vertex
}
else
{
return std::distance( begin, itDown) - 1;
}
}
}
diff --git a/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.cpp b/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.cpp
index 80f4ead147..2df3e9aa89 100644
--- a/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.cpp
+++ b/Modules/Segmentation/Rendering/mitkContourModelGLMapper2D.cpp
@@ -1,282 +1,302 @@
/*===================================================================
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 "mitkContourModelGLMapper2D.h"
#include "mitkBaseRenderer.h"
#include "mitkPlaneGeometry.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "mitkContourModel.h"
#include "mitkContourModelSubDivisionFilter.h"
#include
#include "mitkGL.h"
mitk::ContourModelGLMapper2D::ContourModelGLMapper2D()
{
}
mitk::ContourModelGLMapper2D::~ContourModelGLMapper2D()
{
}
void mitk::ContourModelGLMapper2D::Paint(mitk::BaseRenderer * renderer)
{
BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible ) return;
bool updateNeccesary=true;
int timestep = renderer->GetTimeStep();
mitk::ContourModel::Pointer input = const_cast(this->GetInput());
mitk::ContourModel::Pointer renderingContour = input;
bool subdivision = false;
this->GetDataNode()->GetBoolProperty( "subdivision curve", subdivision, renderer );
if (subdivision)
{
mitk::ContourModel::Pointer subdivContour = mitk::ContourModel::New();
mitk::ContourModelSubDivisionFilter::Pointer subdivFilter = mitk::ContourModelSubDivisionFilter::New();
subdivFilter->SetInput(input);
subdivFilter->Update();
subdivContour = subdivFilter->GetOutput();
if(subdivContour->GetNumberOfVertices() == 0 )
{
subdivContour = input;
}
renderingContour = subdivContour;
}
renderingContour->UpdateOutputInformation();
if( renderingContour->GetMTime() < ls->GetLastGenerateDataTime() )
updateNeccesary = false;
if(renderingContour->GetNumberOfVertices(timestep) < 1)
updateNeccesary = false;
if (updateNeccesary)
{
// 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);
- mitk::ColorProperty::Pointer colorprop = dynamic_cast(GetDataNode()->GetProperty("contour.color", renderer));
+ bool isEditing = false;
+ GetDataNode()->GetBoolProperty("contour.editing", isEditing);
+
+ mitk::ColorProperty::Pointer colorprop;
+
+ if (isEditing)
+ colorprop = dynamic_cast(GetDataNode()->GetProperty("contour.editing.color", renderer));
+ else
+ colorprop = dynamic_cast(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();
glColor4f(red,green,blue,0.5);
}
mitk::ColorProperty::Pointer selectedcolor = dynamic_cast(GetDataNode()->GetProperty("points.color", renderer));
if(!selectedcolor)
{
selectedcolor = mitk::ColorProperty::New(1.0,0.0,0.1);
}
vtkLinearTransform* transform = GetDataNode()->GetVtkTransform();
// ContourModel::OutputType point;
mitk::Point3D point;
mitk::Point3D p, projected_p;
float vtkp[3];
float lineWidth = 3.0;
- if (dynamic_cast(this->GetDataNode()->GetProperty("contour.width")) != NULL)
- lineWidth = dynamic_cast(this->GetDataNode()->GetProperty("contour.width"))->GetValue();
- glLineWidth(lineWidth);
+ bool isHovering = false;
+ this->GetDataNode()->GetBoolProperty("contour.hovering", isHovering);
+ if (isHovering)
+ this->GetDataNode()->GetFloatProperty("contour.hovering.width", lineWidth);
+ else
+ this->GetDataNode()->GetFloatProperty("contour.width", lineWidth);
bool drawit=false;
mitk::ContourModel::VertexIterator pointsIt = renderingContour->IteratorBegin(timestep);
Point2D pt2d; // projected_p in display coordinates
Point2D lastPt2d;
while ( pointsIt != renderingContour->IteratorEnd(timestep) )
{
lastPt2d = pt2d;
point = (*pointsIt)->Coordinates;
itk2vtk(point, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp,p);
displayGeometry->Project(p, projected_p);
displayGeometry->Map(projected_p, pt2d);
displayGeometry->WorldToDisplay(pt2d, pt2d);
Vector3D diff=p-projected_p;
ScalarType scalardiff = diff.GetNorm();
//draw lines
bool projectmode=false;
GetDataNode()->GetVisibility(projectmode, renderer, "contour.project-onto-plane");
if(projectmode)
{
drawit=true;
}
else if(scalardiff<0.25)
{
drawit=true;
}
if(drawit)
{
//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();
}
//draw active 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; glVertex2fv(&tmp[0]);
tmp=pt2d+vert; glVertex2fv(&tmp[0]);
tmp=pt2d+horz; glVertex2fv(&tmp[0]);
tmp=pt2d-vert; glVertex2fv(&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; glVertex2fv(&tmp[0]);
glEnd ();
}
}
pointsIt++;
}//end while iterate over controlpoints
+ // make sure the line is set back to default value
+ glLineWidth(1);
+
//close contour if necessary
if(renderingContour->IsClosed(timestep) && drawit)
{
lastPt2d = pt2d;
point = renderingContour->GetVertexAt(0,timestep)->Coordinates;
itk2vtk(point, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp,p);
displayGeometry->Project(p, projected_p);
displayGeometry->Map(projected_p, pt2d);
displayGeometry->WorldToDisplay(pt2d, pt2d);
glBegin (GL_LINES);
glVertex2f(lastPt2d[0], lastPt2d[1]);
glVertex2f( pt2d[0], pt2d[1] );
glEnd();
}
//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);
displayGeometry->Project(p, projected_p);
displayGeometry->Map(projected_p, pt2d);
displayGeometry->WorldToDisplay(pt2d, pt2d);
Vector3D diff=p-projected_p;
ScalarType scalardiff = diff.GetNorm();
//----------------------------------
//draw point if close to plane
if(scalardiff<0.25)
{
float pointsize = 3.2;
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; glVertex2fv(&tmp[0]);
tmp[0]=pt2d[0]+pointsize; tmp[1]=pt2d[1]+pointsize; glVertex2fv(&tmp[0]);
tmp[0]=pt2d[0]+pointsize; tmp[1]=pt2d[1]-pointsize; glVertex2fv(&tmp[0]);
tmp[0]=pt2d[0]-pointsize; tmp[1]=pt2d[1]-pointsize; glVertex2fv(&tmp[0]);
glEnd ();
}
//------------------------------------
}
}
}
const mitk::ContourModel* mitk::ContourModelGLMapper2D::GetInput(void)
{
return static_cast ( GetDataNode()->GetData() );
}
void mitk::ContourModelGLMapper2D::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.editing", mitk::BoolProperty::New( false ), renderer, overwrite );
+ node->AddProperty( "contour.editing.color", ColorProperty::New(0.1, 0.9, 0.1), renderer, overwrite );
node->AddProperty( "points.color", ColorProperty::New(1.0, 0.0, 0.1), 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( "subdivision curve", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty( "contour.project-onto-plane", mitk::BoolProperty::New( false ), renderer, overwrite );
Superclass::SetDefaultProperties(node, renderer, overwrite);
}