diff --git a/Modules/ContourModel/DataManagement/mitkContourElement.cpp b/Modules/ContourModel/DataManagement/mitkContourElement.cpp
index 3b56894ae2..db490e8ae7 100644
--- a/Modules/ContourModel/DataManagement/mitkContourElement.cpp
+++ b/Modules/ContourModel/DataManagement/mitkContourElement.cpp
@@ -1,502 +1,504 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <algorithm>
#include <mitkContourElement.h>
#include <vtkMath.h>
bool mitk::ContourElement::ContourModelVertex::operator==(const ContourModelVertex &other) const
{
return this->Coordinates == other.Coordinates && this->IsControlPoint == other.IsControlPoint;
}
mitk::ContourElement::ConstVertexIterator mitk::ContourElement::ConstIteratorBegin() const
{
return this->begin();
}
mitk::ContourElement::ConstVertexIterator mitk::ContourElement::ConstIteratorEnd() const
{
return this->end();
}
mitk::ContourElement::VertexIterator mitk::ContourElement::IteratorBegin()
{
return this->begin();
}
mitk::ContourElement::VertexIterator mitk::ContourElement::IteratorEnd()
{
return this->end();
}
mitk::ContourElement::ConstVertexIterator mitk::ContourElement::begin() const
{
return this->m_Vertices.begin();
}
mitk::ContourElement::ConstVertexIterator mitk::ContourElement::end() const
{
return this->m_Vertices.end();
}
mitk::ContourElement::VertexIterator mitk::ContourElement::begin()
{
return this->m_Vertices.begin();
}
mitk::ContourElement::VertexIterator mitk::ContourElement::end()
{
return this->m_Vertices.end();
}
mitk::ContourElement::ContourElement(const mitk::ContourElement &other)
: itk::LightObject(), m_IsClosed(other.m_IsClosed)
{
for (const auto &v : other.m_Vertices)
{
m_Vertices.push_back(new ContourModelVertex(*v));
}
}
mitk::ContourElement &mitk::ContourElement::operator=(const ContourElement &other)
{
if (this != &other)
{
this->Clear();
for (const auto &v : other.m_Vertices)
{
m_Vertices.push_back(new ContourModelVertex(*v));
}
}
this->m_IsClosed = other.m_IsClosed;
return *this;
}
mitk::ContourElement::~ContourElement()
{
this->Clear();
}
mitk::ContourElement::VertexSizeType mitk::ContourElement::GetSize() const
{
return this->m_Vertices.size();
}
void mitk::ContourElement::AddVertex(const mitk::Point3D &vertex, bool isControlPoint)
{
this->m_Vertices.push_back(new VertexType(vertex, isControlPoint));
}
void mitk::ContourElement::AddVertexAtFront(const mitk::Point3D &vertex, bool isControlPoint)
{
this->m_Vertices.push_front(new VertexType(vertex, isControlPoint));
}
void mitk::ContourElement::InsertVertexAtIndex(const mitk::Point3D &vertex, bool isControlPoint, VertexSizeType index)
{
if (index >= 0 && this->GetSize() > index)
{
auto _where = this->m_Vertices.begin();
_where += index;
this->m_Vertices.insert(_where, new VertexType(vertex, isControlPoint));
}
}
void mitk::ContourElement::SetVertexAt(VertexSizeType pointId, const Point3D &point)
{
if (pointId >= 0 && this->GetSize() > pointId)
{
this->m_Vertices[pointId]->Coordinates = point;
}
}
void mitk::ContourElement::SetVertexAt(VertexSizeType pointId, const VertexType *vertex)
{
if (nullptr == vertex)
{
mitkThrow() << "Cannot set vertex. Passed vertex instance is invalid. Index to set: " << pointId;
}
if (pointId >= 0 && this->GetSize() > pointId)
{
this->m_Vertices[pointId]->Coordinates = vertex->Coordinates;
this->m_Vertices[pointId]->IsControlPoint = vertex->IsControlPoint;
}
}
mitk::ContourElement::VertexType *mitk::ContourElement::GetVertexAt(VertexSizeType index)
{
return this->m_Vertices.at(index);
}
const mitk::ContourElement::VertexType *mitk::ContourElement::GetVertexAt(VertexSizeType index) const
{
return this->m_Vertices.at(index);
}
bool mitk::ContourElement::IsEmpty() const
{
return this->m_Vertices.empty();
}
mitk::ContourElement::VertexType *mitk::ContourElement::GetControlVertexAt(const mitk::Point3D &point, float eps)
{
/* current version iterates over the whole deque - should some kind of an octree with spatial query*/
if (eps > 0)
{
// currently no method with better performance is available
return BruteForceGetVertexAt(point, eps, true);
} // if eps < 0
return nullptr;
}
mitk::ContourElement::VertexType *mitk::ContourElement::GetVertexAt(const mitk::Point3D &point, float eps)
{
/* current version iterates over the whole deque - should some kind of an octree with spatial query*/
if (eps > 0)
{
// currently no method with better performance is available
return BruteForceGetVertexAt(point, eps);
} // if eps < 0
return nullptr;
}
mitk::ContourElement::VertexType *mitk::ContourElement::GetNextVertexAt(const mitk::Point3D &point, float eps)
{
/* current version iterates over the whole deque - should some kind of an octree with spatial query*/
if (eps > 0)
{
// currently no method with better performance is available
return BruteForceGetVertexAt(point, eps, true, 1);
} // if eps < 0
return nullptr;
}
mitk::ContourElement::VertexType *mitk::ContourElement::GetPreviousVertexAt(const mitk::Point3D &point, float eps)
{
/* current version iterates over the whole deque - should some kind of an octree with spatial query*/
if (eps > 0)
{
// currently no method with better performance is available
return BruteForceGetVertexAt(point, eps, true, -1);
} // if eps < 0
return nullptr;
}
mitk::ContourElement::VertexType *mitk::ContourElement::BruteForceGetVertexAt(const mitk::Point3D &point,
double eps,
bool isControlPoint,
int offset)
{
VertexListType verticesList;
if (isControlPoint)
{
verticesList = this->GetControlVertexList();
}
else
{
verticesList = *this->GetVertexList();
}
int vertexIndex = BruteForceGetVertexIndexAt(point, eps, verticesList, isControlPoint);
if (vertexIndex!=-1)
{
vertexIndex += offset;
auto size = (int) verticesList.size();
if (vertexIndex < 0)
{
// for negative offset
+ // if the offset exceeds the first vertex, we start from the end of the vertex list backwards
vertexIndex = verticesList.size() + offset;
}
else if (vertexIndex >= verticesList.size())
{
+ // if the offset exceeds the last vertex, we start from the beginning of the vertex list
vertexIndex = vertexIndex - verticesList.size();
}
return verticesList[vertexIndex];
}
return nullptr;
}
int mitk::ContourElement::BruteForceGetVertexIndexAt(const mitk::Point3D &point,
double eps,
VertexListType verticesList,
bool isControlPoint)
{
if (eps < 0)
{
mitkThrow() << "Distance cannot be negative";
}
ConstVertexIterator nearestPointIterator;
bool nearestPointIsInitialized = false;
ConstVertexIterator it = verticesList.begin();
ConstVertexIterator end = verticesList.end();
while (it != end)
{
mitk::Point3D currentPoint = (*it)->Coordinates;
double distance = currentPoint.EuclideanDistanceTo(point);
if (distance < eps)
{
if (!nearestPointIsInitialized || distance < (*nearestPointIterator)->Coordinates.EuclideanDistanceTo(point))
{
nearestPointIterator = it;
nearestPointIsInitialized = true;
}
} // if distance > eps
it++;
} // while
if (nearestPointIsInitialized)
{
return nearestPointIterator - verticesList.begin();
}
return -1;
}
const mitk::ContourElement::VertexListType *mitk::ContourElement::GetVertexList() const
{
return &(this->m_Vertices);
}
const mitk::ContourElement::VertexListType mitk::ContourElement::GetControlVertexList() const
{
VertexListType allList = (this->m_Vertices);
VertexListType out;
ConstVertexIterator begin = allList.begin();
ConstVertexIterator end = allList.end();
std::copy_if(begin, end, std::back_inserter(out), [](VertexType *i) { return i->IsControlPoint; });
// std::copy(begin, end, std::back_inserter(out));
return out;
// return &(this->m_Vertices);
}
bool mitk::ContourElement::IsClosed() const
{
return this->m_IsClosed;
}
bool mitk::ContourElement::IsNearContour(const mitk::Point3D &point, float eps) const
{
ConstVertexIterator it1 = this->m_Vertices.begin();
ConstVertexIterator it2 = this->m_Vertices.begin();
it2++; // it2 runs one position ahead
ConstVertexIterator end = this->m_Vertices.end();
int counter = 0;
for (; it1 != end; it1++, it2++, counter++)
{
if (it2 == end)
it2 = this->m_Vertices.begin();
mitk::Point3D v1 = (*it1)->Coordinates;
mitk::Point3D v2 = (*it2)->Coordinates;
const float l2 = v1.SquaredEuclideanDistanceTo(v2);
mitk::Vector3D p_v1 = point - v1;
mitk::Vector3D v2_v1 = v2 - v1;
double tc = (p_v1 * v2_v1) / l2;
// take into account we have line segments and not (infinite) lines
if (tc < 0.0)
tc = 0.0;
if (tc > 1.0)
tc = 1.0;
mitk::Point3D crossPoint = v1 + v2_v1 * tc;
double distance = point.SquaredEuclideanDistanceTo(crossPoint);
if (distance < eps)
{
return true;
}
}
return false;
}
void mitk::ContourElement::Close()
{
this->m_IsClosed = true;
}
void mitk::ContourElement::Open()
{
this->m_IsClosed = false;
}
void mitk::ContourElement::SetClosed(bool isClosed)
{
isClosed ? this->Close() : this->Open();
}
mitk::ContourElement::VertexListType mitk::ContourElement::GetControlVertices() const
{
VertexListType controlVertices;
std::copy_if(
this->m_Vertices.begin(), this->m_Vertices.end(), std::back_inserter(controlVertices), [](const VertexType *v) {
return v->IsControlPoint;
});
return controlVertices;
}
void mitk::ContourElement::Concatenate(const mitk::ContourElement *other, bool check)
{
if (other->GetSize() > 0)
{
for (const auto &sourceVertex : other->m_Vertices)
{
if (check)
{
auto finding =
std::find_if(this->m_Vertices.begin(), this->m_Vertices.end(), [sourceVertex](const VertexType *v) {
return sourceVertex->Coordinates == v->Coordinates;
});
if (finding == this->m_Vertices.end())
{
this->m_Vertices.push_back(new ContourModelVertex(*sourceVertex));
}
}
else
{
this->m_Vertices.push_back(new ContourModelVertex(*sourceVertex));
}
}
}
}
mitk::ContourElement::VertexSizeType mitk::ContourElement::GetIndex(const VertexType *vertex) const
{
VertexSizeType result = NPOS;
auto finding = std::find(this->m_Vertices.begin(), this->m_Vertices.end(), vertex);
if (finding != this->m_Vertices.end())
{
result = finding - this->m_Vertices.begin();
}
return result;
}
bool mitk::ContourElement::RemoveVertex(const VertexType *vertex)
{
auto finding = std::find(this->m_Vertices.begin(), this->m_Vertices.end(), vertex);
return RemoveVertexByIterator(finding);
}
bool mitk::ContourElement::RemoveVertexAt(VertexSizeType index)
{
if (index >= 0 && index < this->m_Vertices.size())
{
auto delIter = this->m_Vertices.begin() + index;
return RemoveVertexByIterator(delIter);
}
return false;
}
bool mitk::ContourElement::RemoveVertexAt(const mitk::Point3D &point, double eps)
{
if (eps > 0)
{
auto finding = std::find_if(this->m_Vertices.begin(), this->m_Vertices.end(), [point, eps](const VertexType *v) {
return v->Coordinates.EuclideanDistanceTo(point) < eps;
});
return RemoveVertexByIterator(finding);
}
return false;
}
bool mitk::ContourElement::RemoveVertexByIterator(VertexListType::iterator &iter)
{
if (iter != this->m_Vertices.end())
{
delete *iter;
this->m_Vertices.erase(iter);
return true;
}
return false;
}
void mitk::ContourElement::Clear()
{
for (auto vertex : m_Vertices)
{
delete vertex;
}
this->m_Vertices.clear();
}
//----------------------------------------------------------------------
void mitk::ContourElement::RedistributeControlVertices(const VertexType *selected, int period)
{
int counter = 0;
auto _where = this->m_Vertices.begin();
if (selected != nullptr)
{
auto finding = std::find(this->m_Vertices.begin(), this->m_Vertices.end(), selected);
if (finding != this->m_Vertices.end())
{
_where = finding;
}
}
auto _iter = _where;
while (_iter != this->m_Vertices.end())
{
div_t divresult;
divresult = div(counter, period);
(*_iter)->IsControlPoint = (divresult.rem == 0);
counter++;
_iter++;
}
_iter = _where;
counter = 0;
while (_iter != this->m_Vertices.begin())
{
div_t divresult;
divresult = div(counter, period);
(*_iter)->IsControlPoint = (divresult.rem == 0);
counter++;
_iter--;
}
}
diff --git a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
index 187be33ce4..9c75d4e44e 100644
--- a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
+++ b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
@@ -1,541 +1,415 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkContourModelLiveWireInteractor.h"
#include "mitkInteractionPositionEvent.h"
#include "mitkToolManager.h"
#include "mitkBaseRenderer.h"
#include "mitkRenderingManager.h"
#include <mitkInteractionConst.h>
#include "mitkIOUtil.h"
mitk::ContourModelLiveWireInteractor::ContourModelLiveWireInteractor() : ContourModelInteractor()
{
m_LiveWireFilter = mitk::ImageLiveWireContourModelFilter::New();
m_LiveWireFilter->SetUseCostFunction(true);
m_NextActiveVertexDown.Fill(0);
m_NextActiveVertexUp.Fill(0);
}
mitk::ContourModelLiveWireInteractor::~ContourModelLiveWireInteractor()
{
}
void mitk::ContourModelLiveWireInteractor::ConnectActionsAndFunctions()
{
CONNECT_CONDITION("checkisOverPoint", OnCheckPointClick);
CONNECT_CONDITION("mouseMove", IsHovering);
CONNECT_FUNCTION("movePoint", OnMovePoint);
CONNECT_FUNCTION("deletePoint", OnDeletePoint);
CONNECT_FUNCTION("finish", OnFinishEditing);
}
bool mitk::ContourModelLiveWireInteractor::OnCheckPointClick(const InteractionEvent *interactionEvent)
{
const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return false;
const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
if (contour == nullptr)
{
MITK_ERROR << "Invalid Contour";
return false;
}
contour->Deselect();
// Check distance to any vertex.
// Transition YES if click close to a vertex
mitk::Point3D click = positionEvent->GetPositionInWorld();
bool isVertexSelected = false;
// Check, if clicked position is close to control vertex and if so, select closest control vertex.
isVertexSelected = contour->SelectControlVertexAt(click, mitk::ContourModelLiveWireInteractor::eps, timeStep);
// If the position is not close to control vertex. but hovering the contour line, we check, if it is close to non-control vertex.
// The closest vertex will be set as a control vertex.
if (isVertexSelected == false)
isVertexSelected = contour->SelectVertexAt(click, mitk::ContourModelLiveWireInteractor::eps, timeStep);
// If the position is not close to control or non-control vertex. but hovering the contour line, we create a vertex at the position.
if (isVertexSelected == false)
{
bool isHover = false;
if (this->GetDataNode()->GetBoolProperty("contour.hovering", isHover, positionEvent->GetSender()) == false)
{
MITK_WARN << "Unknown property contour.hovering";
}
if (isHover)
{
contour->AddVertex(click, timeStep);
isVertexSelected = contour->SelectVertexAt(click, mitk::ContourModelLiveWireInteractor::eps, timeStep);
}
}
if (isVertexSelected)
{
contour->SetSelectedVertexAsControlPoint(true);
auto controlVertices = contour->GetControlVertexList(timeStep);
const mitk::ContourModel::VertexType *nextPoint = contour->GetNextVertexAt(click, mitk::ContourModelLiveWireInteractor::eps, timeStep);
const mitk::ContourModel::VertexType *previousPoint = contour->GetPreviousVertexAt(click, mitk::ContourModelLiveWireInteractor::eps, timeStep);
this->SplitContourFromSelectedVertex(contour, nextPoint, previousPoint, timeStep);
m_NextActiveVertexUp = nextPoint->Coordinates;
m_NextActiveVertexDown = previousPoint->Coordinates;
// clear container with void points between neighboring control points
m_ContourBeingModified.clear();
// finally, return true to pass this condition
return true;
}
else
{
// do not pass condition
return false;
}
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
return true;
}
void mitk::ContourModelLiveWireInteractor::SetEditingContourModelNode(mitk::DataNode *_arg)
{
if (this->m_EditingContourNode != _arg)
{
this->m_EditingContourNode = _arg;
}
}
void mitk::ContourModelLiveWireInteractor::SetWorkingImage(mitk::Image *_arg)
{
if (this->m_WorkingSlice != _arg)
{
this->m_WorkingSlice = _arg;
this->m_LiveWireFilter->SetInput(this->m_WorkingSlice);
}
}
void mitk::ContourModelLiveWireInteractor::OnDeletePoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
if (contour == nullptr)
{
MITK_ERROR << "Invalid Contour!";
return;
}
if (contour->GetSelectedVertex())
{
mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
newContour->Expand(contour->GetTimeSteps());
newContour->SetTimeGeometry(contour->GetTimeGeometry()->Clone());
newContour->Concatenate(m_ContourLeft, timeStep);
// recompute contour between neighbored two active control points
this->m_LiveWireFilter->SetStartPoint(this->m_NextActiveVertexDown);
this->m_LiveWireFilter->SetEndPoint(this->m_NextActiveVertexUp);
// this->m_LiveWireFilter->ClearRepulsivePoints();
this->m_LiveWireFilter->Update();
mitk::ContourModel *liveWireContour = this->m_LiveWireFilter->GetOutput();
assert(liveWireContour);
if (liveWireContour->IsEmpty(timeStep))
return;
liveWireContour->RemoveVertexAt(0, timeStep);
liveWireContour->RemoveVertexAt(liveWireContour->GetNumberOfVertices(timeStep) - 1, timeStep);
// insert new live wire computed points
newContour->Concatenate(liveWireContour, timeStep);
// insert right side of original contour
newContour->Concatenate(this->m_ContourRight, timeStep);
newContour->SetClosed(contour->IsClosed(timeStep), timeStep);
// instead of leaving a single point, delete all points
if (newContour->GetNumberOfVertices(timeStep) <= 2)
{
newContour->Clear(timeStep);
}
this->GetDataNode()->SetData(newContour);
mitk::RenderingManager::GetInstance()->RequestUpdate(interactionEvent->GetSender()->GetRenderWindow());
}
}
void mitk::ContourModelLiveWireInteractor::OnMovePoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
mitk::Point3D currentPosition = positionEvent->GetPositionInWorld();
auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
if (contour == nullptr)
{
MITK_ERROR << "invalid contour";
return;
}
mitk::ContourModel::Pointer editingContour = mitk::ContourModel::New();
editingContour->Expand(contour->GetTimeSteps());
editingContour->SetTimeGeometry(contour->GetTimeGeometry()->Clone());
// recompute left live wire, i.e. the contour between previous active vertex and selected vertex
this->m_LiveWireFilter->SetStartPoint(this->m_NextActiveVertexDown);
this->m_LiveWireFilter->SetEndPoint(currentPosition);
// remove void positions between previous active vertex and next active vertex.
if (!m_ContourBeingModified.empty())
{
std::vector<itk::Index<2>>::const_iterator iter = m_ContourBeingModified.begin();
for (; iter != m_ContourBeingModified.end(); iter++)
{
this->m_LiveWireFilter->RemoveRepulsivePoint((*iter));
}
}
// update to get the left livewire. Remember that the points in the rest of the contour are already
// set as void positions in the filter
this->m_LiveWireFilter->Update();
mitk::ContourModel::Pointer leftLiveWire = this->m_LiveWireFilter->GetOutput();
assert(leftLiveWire);
if (!leftLiveWire->IsEmpty(timeStep))
leftLiveWire->RemoveVertexAt(0, timeStep);
editingContour->Concatenate(leftLiveWire, timeStep);
// the new index of the selected vertex
unsigned int selectedVertexIndex =
this->m_ContourLeft->GetNumberOfVertices(timeStep) + leftLiveWire->GetNumberOfVertices(timeStep) - 1;
// at this point the container has to be empty
m_ContourBeingModified.clear();
// add points from left live wire contour
auto iter = leftLiveWire->IteratorBegin(timeStep);
for (; iter != leftLiveWire->IteratorEnd(timeStep); iter++)
{
itk::Index<2> idx;
this->m_WorkingSlice->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
this->m_LiveWireFilter->AddRepulsivePoint(idx);
// add indices
m_ContourBeingModified.push_back(idx);
}
// recompute right live wire, i.e. the contour between selected vertex and next active vertex
this->m_LiveWireFilter->SetStartPoint(currentPosition);
this->m_LiveWireFilter->SetEndPoint(m_NextActiveVertexUp);
// update filter with all contour points set as void but the right live wire portion to be calculated now
this->m_LiveWireFilter->Update();
mitk::ContourModel::Pointer rightLiveWire = this->m_LiveWireFilter->GetOutput();
assert(rightLiveWire);
// reject strange paths
if (abs(rightLiveWire->GetNumberOfVertices(timeStep) - leftLiveWire->GetNumberOfVertices(timeStep)) > 50)
{
return;
}
if (!leftLiveWire->IsEmpty(timeStep))
leftLiveWire->SetControlVertexAt(leftLiveWire->GetNumberOfVertices() - 1, timeStep);
if (!rightLiveWire->IsEmpty(timeStep))
rightLiveWire->RemoveVertexAt(0, timeStep);
editingContour->Concatenate(rightLiveWire, timeStep);
m_EditingContourNode->SetData(editingContour);
mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
newContour->Expand(contour->GetTimeSteps());
newContour->SetTimeGeometry(contour->GetTimeGeometry()->Clone());
// concatenate left original contour
newContour->Concatenate(this->m_ContourLeft, timeStep);
newContour->Concatenate(editingContour, timeStep, true);
// set last inserted vertex as selected
newContour->SelectVertexAt(selectedVertexIndex, timeStep);
// set as control point
newContour->SetSelectedVertexAsControlPoint(true);
// concatenate right original contour
newContour->Concatenate(this->m_ContourRight, timeStep);
newContour->SetClosed(contour->IsClosed(timeStep), timeStep);
this->GetDataNode()->SetData(newContour);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
bool mitk::ContourModelLiveWireInteractor::IsHovering(const InteractionEvent *interactionEvent)
{
const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return false;
const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
mitk::Point3D currentPosition = positionEvent->GetPositionInWorld();
bool isHover = false;
this->GetDataNode()->GetBoolProperty("contour.hovering", isHover, positionEvent->GetSender());
if (contour->IsNearContour(currentPosition, mitk::ContourModelLiveWireInteractor::eps, timeStep))
{
if (isHover == false)
{
this->GetDataNode()->SetBoolProperty("contour.hovering", true);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
return true;
}
else
{
if (isHover == true)
{
this->GetDataNode()->SetBoolProperty("contour.hovering", false);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
}
return false;
}
-int mitk::ContourModelLiveWireInteractor::SplitContourFromSelectedVertex(mitk::ContourModel *srcContour,
- mitk::ContourModel *destContour,
- bool fromSelectedUpwards,
- int timestep)
-{
- auto end = srcContour->IteratorEnd();
- auto begin = srcContour->IteratorBegin();
-
- // search next active control point to left and rigth and set as start and end point for filter
- auto itSelected = begin;
-
- // move iterator to position
- while ((*itSelected) != srcContour->GetSelectedVertex())
- {
- itSelected++;
- }
-
- // CASE search upwards for next control point
- if (fromSelectedUpwards)
- {
- auto itUp = itSelected;
-
- if (itUp != end)
- {
- itUp++; // step once up otherwise the loop breaks immediately
- }
-
- while (itUp != end && !((*itUp)->IsControlPoint))
- {
- itUp++;
- }
-
- auto it = itUp;
-
- if (itSelected != begin)
- {
- // copy the rest of the original contour
- while (it != end)
- {
- destContour->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
- {
- auto itDown = itSelected;
- auto it = srcContour->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
- destContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timestep);
- it++;
- }
- // copy from begin to itDown
- while (it <= itDown)
- {
- destContour->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 != begin)
- {
- 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
- destContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timestep);
- it++;
- }
- }
- /*
- //add vertex at itDown - it's not considered during while loop
- if( it != begin && it != end)
- {
- //destContour->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;
- }
- }
-}
-
void mitk::ContourModelLiveWireInteractor::SplitContourFromSelectedVertex(mitk::ContourModel *srcContour,
const mitk::ContourModel::VertexType *nextPoint,
const mitk::ContourModel::VertexType *previousPoint,
int timeStep)
{
m_ContourLeft = mitk::ContourModel::New();
m_ContourRight = mitk::ContourModel::New();
auto it = srcContour->IteratorBegin();
+ // part between nextPoint and end of Countour
bool upperPart = false;
+ // part between start of countour and previousPoint
bool lowerPart = true;
// edge cases when point right before first control vertex is selected or first control vertex is selected
if (nextPoint == (*it) || srcContour->GetSelectedVertex() == (*it))
{
upperPart = true;
lowerPart = false;
m_ContourLeft->AddVertex(previousPoint->Coordinates, previousPoint->IsControlPoint, timeStep);
}
// if first control vertex is selected, move to next point before adding vertices to m_ContourRight
// otherwise, second line appears when moving the vertex
if (srcContour->GetSelectedVertex() == (*it))
{
while (*it != nextPoint)
{
it++;
}
}
// clear previous void positions
this->m_LiveWireFilter->ClearRepulsivePoints();
for (; it != srcContour->IteratorEnd(timeStep); it++)
{
+ // everything in lower part should be added to m_CountoutLeft
if (lowerPart)
{
m_ContourLeft->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timeStep);
}
-
+ // start of "restricted area" where no vertex should be added to m_CountoutLeft or m_CountoutRight
if (*it == previousPoint)
{
lowerPart = false;
upperPart = false;
}
-
+ // start of upperPart
if (*it == nextPoint)
{
upperPart = true;
}
-
+ // everything in upper part should be added to m_CountoutRight
if (upperPart)
{
m_ContourRight->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timeStep);
}
-
+ // all points in lower and upper part should be marked as repulsive points to not be changed
if ((lowerPart && *it != previousPoint) || (upperPart && *it != nextPoint))
{
itk::Index<2> idx;
this->m_WorkingSlice->GetGeometry()->WorldToIndex((*it)->Coordinates, idx);
this->m_LiveWireFilter->AddRepulsivePoint(idx);
}
}
}
void mitk::ContourModelLiveWireInteractor::OnFinishEditing(StateMachineAction *, InteractionEvent *interactionEvent)
{
const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
auto *editingContour = dynamic_cast<mitk::ContourModel *>(this->m_EditingContourNode->GetData());
editingContour->Clear(timeStep);
mitk::RenderingManager::GetInstance()->RequestUpdate(interactionEvent->GetSender()->GetRenderWindow());
}
diff --git a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.h b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.h
index d075ffa19b..c96c5bd23c 100644
--- a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.h
+++ b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.h
@@ -1,90 +1,85 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkContourModelLiveWireInteractor_h_Included
#define mitkContourModelLiveWireInteractor_h_Included
#include "mitkCommon.h"
#include "mitkContourModelInteractor.h"
#include <MitkSegmentationExports.h>
#include <mitkImageLiveWireContourModelFilter.h>
namespace mitk
{
/**
\brief
\sa Interactor
\sa ContourModelInteractor
\ingroup Interaction
\warning Make sure the working image is properly set, otherwise the algorithm for computing livewire contour segments
will not work!
*/
class MITKSEGMENTATION_EXPORT ContourModelLiveWireInteractor : public ContourModelInteractor
{
public:
mitkClassMacro(ContourModelLiveWireInteractor, ContourModelInteractor);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
virtual void SetEditingContourModelNode(mitk::DataNode *_arg);
virtual void SetWorkingImage(mitk::Image *_arg);
void ConnectActionsAndFunctions() override;
protected:
ContourModelLiveWireInteractor();
~ContourModelLiveWireInteractor() override;
bool OnCheckPointClick(const InteractionEvent *interactionEvent) override;
bool IsHovering(const InteractionEvent *interactionEvent) override;
void OnMovePoint(StateMachineAction *, InteractionEvent *interactionEvent) override;
void OnDeletePoint(StateMachineAction *, InteractionEvent *interactionEvent) override;
void OnFinishEditing(StateMachineAction *, InteractionEvent *interactionEvent) override;
- int SplitContourFromSelectedVertex(mitk::ContourModel *srcContour,
- mitk::ContourModel *destContour,
- bool fromSelectedUpwards,
- int timestep);
-
void SplitContourFromSelectedVertex(mitk::ContourModel *srcContour,
const mitk::ContourModel::VertexType *nextPoint,
const mitk::ContourModel::VertexType *previousPoint,
int timestep);
const float eps = 3.0;
mitk::ImageLiveWireContourModelFilter::Pointer m_LiveWireFilter;
mitk::Image::Pointer m_WorkingSlice;
mitk::Point3D m_NextActiveVertexDown;
mitk::Point3D m_NextActiveVertexUp;
mitk::ContourModel::VertexIterator m_NextActiveVertexDownIter;
mitk::ContourModel::VertexIterator m_NextActiveVertexUpIter;
std::vector<itk::Index<2>> m_ContourBeingModified;
mitk::DataNode::Pointer m_EditingContourNode;
mitk::ContourModel::Pointer m_ContourLeft;
mitk::ContourModel::Pointer m_ContourRight;
};
} // namespace mitk
#endif // mitkContourModelLiveWireInteractor_h_Included