diff --git a/Core/Code/Resources/Interactions/Legacy/StateMachine.xml b/Core/Code/Resources/Interactions/Legacy/StateMachine.xml
index 7db131ef6b..32df1fc23e 100644
--- a/Core/Code/Resources/Interactions/Legacy/StateMachine.xml
+++ b/Core/Code/Resources/Interactions/Legacy/StateMachine.xml
@@ -1,4145 +1,4148 @@
+
+
+
diff --git a/Modules/GraphAlgorithms/itkShortestPathCostFunctionLiveWire.h b/Modules/GraphAlgorithms/itkShortestPathCostFunctionLiveWire.h
index 40a22d6a86..6952d329b2 100644
--- a/Modules/GraphAlgorithms/itkShortestPathCostFunctionLiveWire.h
+++ b/Modules/GraphAlgorithms/itkShortestPathCostFunctionLiveWire.h
@@ -1,188 +1,200 @@
/*===================================================================
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 __itkShortestPathCostFunctionLiveWire_h
#define __itkShortestPathCostFunctionLiveWire_h
#include "itkShortestPathCostFunction.h"
#include "itkImageRegionConstIterator.h"
namespace itk
{
/** \brief Cost function for LiveWire purposes.
Specific features are considered to calculate cummulative
costs of a link between two pixels. These are:
- Gradient Magnitude
- Gradient Direction
- Laplacian Zero Crossing
By default the Gradient Magnitude is mapped linearly to cost values
between 0 (good) and 1 (bad). Via SetDynamicCostMap( std::map< int, int > &costMap)
a cost map can be set to dynamically map Gradient Magnitude (non
linear). Thus, lower values can be considered with lower costs
than higher values of gradient magnitudes.
To compute the costs of the gradient magnitude dynamically
an iverted map of the histogram of gradient magnitude image is used.
*/
template
class ITK_EXPORT ShortestPathCostFunctionLiveWire : public ShortestPathCostFunction
{
public:
/** Standard class typedefs. */
typedef ShortestPathCostFunctionLiveWire Self;
typedef ShortestPathCostFunction Superclass;
typedef SmartPointer Pointer;
typedef SmartPointer ConstPointer;
typedef itk::ImageRegionConstIterator ConstIteratorType;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(ShortestPathCostFunctionLiveWire, ShortestPathCostFunction);
typedef itk::Image UnsignedCharImageType;
typedef itk::Image FloatImageType;
typedef float ComponentType;
typedef itk::CovariantVector< ComponentType, 2 > OutputPixelType;
typedef itk::Image< OutputPixelType, 2 > VectorOutputImageType;
typedef typename TInputImageType::IndexType IndexType;
typedef TInputImageType ImageType;
typedef itk::ImageRegion<2> RegionType;
/** \brief calculates the costs for going from p1 to p2*/
virtual double GetCost(IndexType p1, IndexType p2);
/** \brief returns the minimal costs possible (needed for A*)*/
virtual double GetMinCost();
/** \brief Initialize the metric*/
virtual void Initialize ();
/** \brief Add void pixel in cost map*/
virtual void AddRepulsivePoint( const IndexType& index );
/** \brief Remove void pixel in cost map*/
virtual void RemoveRepulsivePoint( const IndexType& index );
/** \brief Clear repulsive points in cost function*/
virtual void ClearRepulsivePoints();
itkSetMacro (RequestedRegion, RegionType);
itkGetMacro (RequestedRegion, RegionType);
// Set/Get function for sigma parameter
itkSetMacro (UseApproximateGradient, bool);
itkGetMacro (UseApproximateGradient, bool);
virtual void SetImage(const TInputImageType* _arg);
void SetDynamicCostMap( std::map< int, int > &costMap)
{
this->m_CostMap = costMap;
this->m_UseCostMap = true;
this->m_MaxMapCosts = -1;
this->Modified();
}
void SetUseCostMap(bool useCostMap)
{
this->m_UseCostMap = useCostMap;
}
/**
\brief Set the maximum of the dynamic cost map to save computation time.
*/
void SetCostMapMaximum(double max)
{
this->m_MaxMapCosts = max;
}
enum Constants{
MAPSCALEFACTOR = 10
};
/** \brief Returns the y value of gaussian with given offset and amplitude
gaussian approximation
f(x) = v(bin) * e^ ( -1/2 * (|x-k(bin)| / sigma)^2 )
\param x
\param xOfGaussian - offset
\param yOfGaussian - amplitude
*/
static double Gaussian(double x, double xOfGaussian, double yOfGaussian);
+ const UnsignedCharImageType* GetMaskImage()
+ { return this->m_MaskImage.GetPointer(); };
+
+ const FloatImageType* GetGradientMagnitudeImage()
+ { return this->m_GradientMagnitudeImage.GetPointer(); };
+
+ const FloatImageType* GetEdgeImage()
+ { return this->m_EdgeImage.GetPointer(); };
+
+ const VectorOutputImageType* GetGradientImage()
+ { return this->m_GradientImage.GetPointer(); };
+
protected:
ShortestPathCostFunctionLiveWire();
virtual ~ShortestPathCostFunctionLiveWire() {};
- UnsignedCharImageType::Pointer m_MaskImage;
+
FloatImageType::Pointer m_GradientMagnitudeImage;
-// UnsignedCharImageType::Pointer m_ZeroCrossingImage;
FloatImageType::Pointer m_EdgeImage;
+ UnsignedCharImageType::Pointer m_MaskImage;
VectorOutputImageType::Pointer m_GradientImage;
double minCosts;
bool m_UseRepulsivePoints;
typename Superclass::PixelType val;
typename Superclass::PixelType startValue;
typename Superclass::PixelType endValue;
double m_GradientMax;
RegionType m_RequestedRegion;
bool m_UseApproximateGradient;
bool m_Initialized;
std::map< int, int > m_CostMap;
bool m_UseCostMap;
double m_MaxMapCosts;
private:
double SigmoidFunction(double I, double max, double min, double alpha, double beta);
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkShortestPathCostFunctionLiveWire.txx"
#endif
#endif /* __itkShortestPathCostFunctionLiveWire_h */
diff --git a/Modules/GraphAlgorithms/itkShortestPathCostFunctionLiveWire.txx b/Modules/GraphAlgorithms/itkShortestPathCostFunctionLiveWire.txx
index 4f2fae2b42..5afae1f6e5 100644
--- a/Modules/GraphAlgorithms/itkShortestPathCostFunctionLiveWire.txx
+++ b/Modules/GraphAlgorithms/itkShortestPathCostFunctionLiveWire.txx
@@ -1,443 +1,440 @@
/*===================================================================
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 __itkShortestPathCostFunctionLiveWire_txx
#define __itkShortestPathCostFunctionLiveWire_txx
#include "itkShortestPathCostFunctionLiveWire.h"
#include
#include
#include
#include
#include
#include
#include
#include
namespace itk
{
// Constructor
template
ShortestPathCostFunctionLiveWire
::ShortestPathCostFunctionLiveWire()
{
m_UseRepulsivePoints = false;
m_GradientMax = 0.0;
m_Initialized = false;
m_UseCostMap = false;
m_MaxMapCosts = -1.0;
}
template
void ShortestPathCostFunctionLiveWire
::AddRepulsivePoint( const IndexType& index )
{
- if (this->m_MaskImage.IsNotNull())
- this->m_MaskImage->SetPixel(index, 255);
+ m_MaskImage->SetPixel(index, 255);
m_UseRepulsivePoints = true;
}
template
void ShortestPathCostFunctionLiveWire
::RemoveRepulsivePoint( const IndexType& index )
{
- if (this->m_MaskImage.IsNotNull())
- this->m_MaskImage->SetPixel(index, 0);
+ this->m_MaskImage->SetPixel(index, 0);
}
template
void ShortestPathCostFunctionLiveWire
::SetImage(const TInputImageType* _arg)
{
if (m_Image != _arg)
{
m_Image = _arg;
// initialize mask image
m_MaskImage = UnsignedCharImageType::New();
m_MaskImage->SetRegions(m_Image->GetLargestPossibleRegion());
m_MaskImage->SetOrigin( m_Image->GetOrigin() );
m_MaskImage->SetSpacing( m_Image->GetSpacing() );
m_MaskImage->SetDirection( m_Image->GetDirection() );
m_MaskImage->Allocate ();
m_MaskImage->FillBuffer(0);
this->Modified();
this->m_Initialized = false;
}
}
template
void ShortestPathCostFunctionLiveWire
::ClearRepulsivePoints()
{
m_UseRepulsivePoints = false;
- if (this->m_MaskImage.IsNotNull())
- this->m_MaskImage->FillBuffer(0);
+ m_MaskImage->FillBuffer(0);
}
template
double ShortestPathCostFunctionLiveWire
::GetCost(IndexType p1 ,IndexType p2)
{
// local component costs
// weights
double w1;
double w2;
double w3;
double costs = 0.0;
// if we are on the mask, return asap
if (m_UseRepulsivePoints)
{
if ( (this->m_MaskImage->GetPixel(p1) != 0) ||
(this->m_MaskImage->GetPixel(p2) != 0) )
- return 255;
+ return 1000;
}
unsigned long xMAX = this->m_Image->GetLargestPossibleRegion().GetSize()[0];
unsigned long yMAX = this->m_Image->GetLargestPossibleRegion().GetSize()[1];
double gradientX, gradientY;
gradientX = gradientY = 0.0;
double gradientCost;
double gradientMagnitude;
// Gradient Magnitude costs
gradientMagnitude = this->m_GradientMagnitudeImage->GetPixel(p2);
gradientX = m_GradientImage->GetPixel(p2)[0];
gradientY = m_GradientImage->GetPixel(p2)[1];
if(m_UseCostMap && !m_CostMap.empty())
{
std::map< int, int >::iterator end = m_CostMap.end();
std::map< int, int >::iterator last = --(m_CostMap.end());
//current position
std::map< int, int >::iterator x;
//std::map< int, int >::key_type keyOfX = static_cast::key_type>(gradientMagnitude * 1000);
int keyOfX = static_cast(gradientMagnitude /* ShortestPathCostFunctionLiveWire::MAPSCALEFACTOR*/);
x = m_CostMap.find( keyOfX );
std::map< int, int >::iterator left2;
std::map< int, int >::iterator left1;
std::map< int, int >::iterator right1;
std::map< int, int >::iterator right2;
if( x == end )
{//x can also be == end if the key is not in the map but between two other keys
//search next key within map from x upwards
right1 = m_CostMap.lower_bound( keyOfX );
}
else
{
right1 = x;
}
if(right1 == end || right1 == last )
{
right2 = end;
}
else//( right1 != (end-1) )
{
std::map< int, int >::iterator temp = right1;
right2 = ++right1;//rght1 + 1
right1 = temp;
}
if( right1 == m_CostMap.begin() )
{
left1 = end;
left2 = end;
}
else if( right1 == (++(m_CostMap.begin())) )
{
std::map< int, int >::iterator temp = right1;
left1 = --right1;//rght1 - 1
right1 = temp;
left2 = end;
}
else
{
std::map< int, int >::iterator temp = right1;
left1 = --right1;//rght1 - 1
left2 = --right1;//rght1 - 2
right1 = temp;
}
double partRight1, partRight2, partLeft1, partLeft2;
partRight1 = partRight2 = partLeft1 = partLeft2 = 0.0;
/*
f(x) = v(bin) * e^ ( -1/2 * (|x-k(bin)| / sigma)^2 )
gaussian approximation
where
v(bin) is the value in the map
k(bin) is the key
*/
if( left2 != end )
{
partLeft2 = ShortestPathCostFunctionLiveWire::Gaussian(keyOfX, left2->first, left2->second);
}
if( left1 != end )
{
partLeft1 = ShortestPathCostFunctionLiveWire::Gaussian(keyOfX, left1->first, left1->second);
}
if( right1 != end )
{
partRight1 = ShortestPathCostFunctionLiveWire::Gaussian(keyOfX, right1->first, right1->second);
}
if( right2 != end )
{
partRight2 = ShortestPathCostFunctionLiveWire::Gaussian(keyOfX, right2->first, right2->second);
}
if( m_MaxMapCosts > 0.0 )
{
gradientCost = 1.0 - ( (partRight1 + partRight2 + partLeft1 + partLeft2) / m_MaxMapCosts );
}
else
{//use linear mapping
gradientCost = 1.0 - (gradientMagnitude / m_GradientMax);
}
}
else
{//use linear mapping
//value between 0 (good) and 1 (bad)
gradientCost = 1.0 - (gradientMagnitude / m_GradientMax);
}
// Laplacian zero crossing costs
// f(p) = 0; if I(p)=0
// or 1; if I(p)!=0
double laplacianCost;
typename Superclass::PixelType laplaceImageValue;
laplaceImageValue = m_EdgeImage->GetPixel(p2);
if(laplaceImageValue < 0 || laplaceImageValue > 0)
{
laplacianCost = 1.0;
}
else
{
laplacianCost = 0.0;
}
// Gradient direction costs
//vector q-p i.e. p2-p1
double vQP[2];
vQP[0] = p2[0] - p1[0];
vQP[1] = p2[1] - p1[1];
//-------
//vector p-q i.e. p1-p2
double vPQ[2];
vPQ[0] = p1[0] - p2[0];
vPQ[1] = p1[1] - p2[1];
//-------
// gradient vector at p1
double nGradientAtP1[2];
nGradientAtP1[0] = gradientX;//previously computed for gradient magnitude
nGradientAtP1[1] = gradientY;
//gradient direction unit vector of p1
nGradientAtP1[0] /= gradientMagnitude;
nGradientAtP1[1] /= gradientMagnitude;
//-------
// gradient vector at p1
double nGradientAtP2[2];
nGradientAtP2[0] = m_GradientImage->GetPixel(p2)[0];
nGradientAtP2[1] = m_GradientImage->GetPixel(p2)[1];
nGradientAtP2[0] /= m_GradientMagnitudeImage->GetPixel(p2);
nGradientAtP2[1] /= m_GradientMagnitudeImage->GetPixel(p2);
double scalarProduct = (nGradientAtP1[0] * nGradientAtP2[0]) + (nGradientAtP1[1] * nGradientAtP2[1]);
if( abs(scalarProduct) >= 1.0)
{
//this should probably not happen; make sure the input for acos is valid
scalarProduct = 0.999999999;
}
double gradientDirectionCost = acos( scalarProduct ) / 3.14159265;
if (this->m_UseCostMap)
{
w1 = 0.43;
w2= 0.43;
w3 = 0.14;
}else{
w1 = 0.10;
w2= 0.85;
w3 = 0.05;
}
costs = w1 * laplacianCost + w2 * gradientCost + w3 * gradientDirectionCost;
//scale by euclidian distance
double costScale;
if( p1[0] == p2[0] || p1[1] == p2[1])
{
//horizontal or vertical neighbor
costScale = 1.0;
}
else
{
//diagonal neighbor
costScale = sqrt(2.0);
}
costs *= costScale;
return costs;
}
template
double ShortestPathCostFunctionLiveWire
::GetMinCost()
{
return minCosts;
}
template
void ShortestPathCostFunctionLiveWire
::Initialize()
{
if(!m_Initialized)
{
typedef itk::CastImageFilter< TInputImageType, FloatImageType > CastFilterType;
typename CastFilterType::Pointer castFilter = CastFilterType::New();
castFilter->SetInput(this->m_Image);
// init gradient magnitude image
typedef itk::GradientMagnitudeImageFilter< FloatImageType, FloatImageType> GradientMagnitudeFilterType;
typename GradientMagnitudeFilterType::Pointer gradientFilter = GradientMagnitudeFilterType::New();
gradientFilter->SetInput(castFilter->GetOutput());
//gradientFilter->SetNumberOfThreads(4);
//gradientFilter->GetOutput()->SetRequestedRegion(m_RequestedRegion);
gradientFilter->Update();
this->m_GradientMagnitudeImage = gradientFilter->GetOutput();
typedef itk::StatisticsImageFilter StatisticsImageFilterType;
typename StatisticsImageFilterType::Pointer statisticsImageFilter = StatisticsImageFilterType::New();
statisticsImageFilter->SetInput(this->m_GradientMagnitudeImage);
statisticsImageFilter->Update();
m_GradientMax = statisticsImageFilter->GetMaximum();
typedef itk::GradientImageFilter< FloatImageType > GradientFilterType;
typename GradientFilterType::Pointer filter = GradientFilterType::New();
//sigma is specified in millimeters
//filter->SetSigma( 1.5 );
filter->SetInput(castFilter->GetOutput());
filter->Update();
m_GradientImage = filter->GetOutput();
// init zero crossings
//typedef itk::ZeroCrossingImageFilter< TInputImageType, UnsignedCharImageType > ZeroCrossingImageFilterType;
//ZeroCrossingImageFilterType::Pointer zeroCrossingImageFilter = ZeroCrossingImageFilterType::New();
//zeroCrossingImageFilter->SetInput(this->m_Image);
//zeroCrossingImageFilter->SetBackgroundValue(1);
//zeroCrossingImageFilter->SetForegroundValue(0);
//zeroCrossingImageFilter->SetNumberOfThreads(4);
//zeroCrossingImageFilter->Update();
//m_EdgeImage = zeroCrossingImageFilter->GetOutput();
//cast image to float to apply canny edge dection filter
/*typedef itk::CastImageFilter< TInputImageType, FloatImageType > CastFilterType;
CastFilterType::Pointer castFilter = CastFilterType::New();
castFilter->SetInput(this->m_Image);*/
//typedef itk::LaplacianImageFilter filterType;
//filterType::Pointer laplacianFilter = filterType::New();
//laplacianFilter->SetInput( castFilter->GetOutput() ); // NOTE: input image type must be double or float
//laplacianFilter->Update();
//m_EdgeImage = laplacianFilter->GetOutput();
//init canny edge detection
typedef itk::CannyEdgeDetectionImageFilter CannyEdgeDetectionImageFilterType;
typename CannyEdgeDetectionImageFilterType::Pointer cannyEdgeDetectionfilter = CannyEdgeDetectionImageFilterType::New();
cannyEdgeDetectionfilter->SetInput(castFilter->GetOutput());
cannyEdgeDetectionfilter->SetUpperThreshold(30);
cannyEdgeDetectionfilter->SetLowerThreshold(15);
cannyEdgeDetectionfilter->SetVariance(4);
cannyEdgeDetectionfilter->SetMaximumError(.01f);
cannyEdgeDetectionfilter->Update();
m_EdgeImage = cannyEdgeDetectionfilter->GetOutput();
// set minCosts
minCosts = 0.0; // The lower, the more thouroughly! 0 = dijkstra. If estimate costs are lower than actual costs everything is fine. If estimation is higher than actual costs, you might not get the shortest but a different path.
m_Initialized = true;
}
// check start/end point value
startValue= this->m_Image->GetPixel(this->m_StartIndex);
endValue= this->m_Image->GetPixel(this->m_EndIndex);
}
template
double ShortestPathCostFunctionLiveWire::SigmoidFunction(double I, double max, double min, double alpha, double beta)
{
// Using the SIgmoid formula from ITK Software Guide 6.3.2 Non Linear Mappings
double Exponent = -1 * ((I - beta) / alpha);
double Factor = 1 / (1 + exp(Exponent));
double newI = (max - min) * Factor + min;
return newI;
}
template
double ShortestPathCostFunctionLiveWire::Gaussian(double x, double xOfGaussian, double yOfGaussian)
{
return yOfGaussian * exp( -0.5 * pow( (x - xOfGaussian), 2) );
}
} // end namespace itk
#endif // __itkShortestPathCostFunctionLiveWire_txx
diff --git a/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.cpp b/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.cpp
index a4f59edefd..c2e422c56f 100644
--- a/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.cpp
+++ b/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.cpp
@@ -1,438 +1,444 @@
/*===================================================================
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 "mitkImageLiveWireContourModelFilter.h"
#include
#include
#include
+#include "mitkIOUtil.h"
mitk::ImageLiveWireContourModelFilter::ImageLiveWireContourModelFilter()
{
OutputType::Pointer output = dynamic_cast ( this->MakeOutput( 0 ).GetPointer() );
this->SetNumberOfRequiredInputs(1);
this->SetNumberOfIndexedOutputs( 1 );
this->SetNthOutput(0, output.GetPointer());
m_CostFunction = CostFunctionType::New();
m_ShortestPathFilter = ShortestPathImageFilterType::New();
m_ShortestPathFilter->SetCostFunction(m_CostFunction);
m_UseDynamicCostMap = false;
- m_ImageModified = false;
m_TimeStep = 0;
}
mitk::ImageLiveWireContourModelFilter::~ImageLiveWireContourModelFilter()
{
}
mitk::ImageLiveWireContourModelFilter::OutputType* mitk::ImageLiveWireContourModelFilter::GetOutput()
{
return Superclass::GetOutput();
}
void mitk::ImageLiveWireContourModelFilter::SetInput ( const mitk::ImageLiveWireContourModelFilter::InputType* input )
{
this->SetInput( 0, input );
}
void mitk::ImageLiveWireContourModelFilter::SetInput ( unsigned int idx, const mitk::ImageLiveWireContourModelFilter::InputType* input )
{
if ( idx + 1 > this->GetNumberOfInputs() )
{
this->SetNumberOfRequiredInputs(idx + 1);
}
if ( input != static_cast ( this->ProcessObject::GetInput ( idx ) ) )
{
this->ProcessObject::SetNthInput ( idx, const_cast ( input ) );
this->Modified();
- this->m_ImageModified = true;
- m_ShortestPathFilter = ShortestPathImageFilterType::New();
- m_ShortestPathFilter->SetCostFunction(m_CostFunction);
+
+ AccessFixedDimensionByItk(input, ItkPreProcessImage, 2);
}
}
const mitk::ImageLiveWireContourModelFilter::InputType* mitk::ImageLiveWireContourModelFilter::GetInput( void )
{
if (this->GetNumberOfInputs() < 1)
return NULL;
return static_cast(this->ProcessObject::GetInput(0));
}
const mitk::ImageLiveWireContourModelFilter::InputType* mitk::ImageLiveWireContourModelFilter::GetInput( unsigned int idx )
{
if (this->GetNumberOfInputs() < 1)
return NULL;
return static_cast(this->ProcessObject::GetInput(idx));
}
void mitk::ImageLiveWireContourModelFilter::GenerateData()
{
mitk::Image::ConstPointer input = dynamic_cast(this->GetInput());
if(!input)
{
MITK_ERROR << "No input available.";
itkExceptionMacro("mitk::ImageToLiveWireContourFilter: No input available. Please set the input!");
return;
}
if( input->GetDimension() != 2 )
{
MITK_ERROR << "Filter is only working on 2D images.";
itkExceptionMacro("mitk::ImageToLiveWireContourFilter: Filter is only working on 2D images.. Please make sure that the input is 2D!");
return;
}
- if( m_ImageModified )
- {
- AccessFixedDimensionByItk(input, ItkPreProcessImage, 2);
- m_ImageModified = false;
- }
-
input->GetGeometry()->WorldToIndex(m_StartPoint, m_StartPointInIndex);
input->GetGeometry()->WorldToIndex(m_EndPoint, m_EndPointInIndex);
//only start calculating if both indices are inside image geometry
if( input->GetGeometry()->IsIndexInside(this->m_StartPointInIndex) && input->GetGeometry()->IsIndexInside(this->m_EndPointInIndex) )
{
try
{
this->UpdateLiveWire();
}
catch( itk::ExceptionObject & e )
{
MITK_INFO << "Exception caught during live wiring calculation: " << e;
- m_ImageModified = true;
return;
}
}
}
template
void mitk::ImageLiveWireContourModelFilter::ItkPreProcessImage (itk::Image* inputImage)
{
typedef itk::Image< TPixel, VImageDimension > InputImageType;
typedef itk::CastImageFilter< InputImageType, InternalImageType > CastFilterType;
typename CastFilterType::Pointer castFilter = CastFilterType::New();
castFilter->SetInput(inputImage);
castFilter->Update();
m_InternalImage = castFilter->GetOutput();
m_CostFunction->SetImage( m_InternalImage );
m_ShortestPathFilter->SetInput( m_InternalImage );
}
void mitk::ImageLiveWireContourModelFilter::ClearRepulsivePoints()
{
m_CostFunction->ClearRepulsivePoints();
}
void mitk::ImageLiveWireContourModelFilter::AddRepulsivePoint( const itk::Index<2>& idx )
{
m_CostFunction->AddRepulsivePoint(idx);
}
+void mitk::ImageLiveWireContourModelFilter::DumpMaskImage()
+{
+ mitk::Image::Pointer mask = mitk::Image::New();
+ mask->InitializeByItk( this->m_CostFunction->GetMaskImage() );
+ mask->SetVolume( this->m_CostFunction->GetMaskImage()->GetBufferPointer() );
+ mitk::IOUtil::SaveImage(mask, "G:\\Data\\mask.nrrd");
+/*
+ mitk::Image::Pointer slice = mitk::Image::New();
+ slice->InitializeByItk( this->m_CostFunction->m_MaskImage.GetPointer() );
+ slice->SetVolume(this->m_CostFunction->m_MaskImage->GetBufferPointer());
+ */
+
+}
+
void mitk::ImageLiveWireContourModelFilter::RemoveRepulsivePoint( const itk::Index<2>& idx )
{
m_CostFunction->RemoveRepulsivePoint(idx);
}
void mitk::ImageLiveWireContourModelFilter::SetRepulsivePoints(const ShortestPathType& points)
{
m_CostFunction->ClearRepulsivePoints();
ShortestPathType::const_iterator iter = points.begin();
for (;iter != points.end(); iter++)
{
m_CostFunction->AddRepulsivePoint( (*iter) );
}
}
void mitk::ImageLiveWireContourModelFilter::UpdateLiveWire()
{
// compute the requested region for itk filters
InternalImageType::IndexType startPoint, endPoint;
startPoint[0] = m_StartPointInIndex[0];
startPoint[1] = m_StartPointInIndex[1];
endPoint[0] = m_EndPointInIndex[0];
endPoint[1] = m_EndPointInIndex[1];
// minimum value in each direction for startRegion
InternalImageType::IndexType startRegion;
startRegion[0] = startPoint[0] < endPoint[0] ? startPoint[0] : endPoint[0];
startRegion[1] = startPoint[1] < endPoint[1] ? startPoint[1] : endPoint[1];
// maximum value in each direction for size
InternalImageType::SizeType size;
size[0] = abs( startPoint[0] - endPoint[0] ) + 1;
size[1] = abs( startPoint[1] - endPoint[1] ) + 1;
CostFunctionType::RegionType region;
region.SetSize( size );
region.SetIndex( startRegion );
//inputImage->SetRequestedRegion(region);
// extracts features from image and calculates costs
//m_CostFunction->SetImage(m_InternalImage);
m_CostFunction->SetStartIndex(startPoint);
m_CostFunction->SetEndIndex(endPoint);
m_CostFunction->SetRequestedRegion(region);
m_CostFunction->SetUseCostMap(m_UseDynamicCostMap);
// calculate shortest path between start and end point
m_ShortestPathFilter->SetFullNeighborsMode(true);
//m_ShortestPathFilter->SetInput( m_CostFunction->SetImage(m_InternalImage) );
m_ShortestPathFilter->SetMakeOutputImage(false);
//m_ShortestPathFilter->SetCalcAllDistances(true);
m_ShortestPathFilter->SetStartIndex(startPoint);
m_ShortestPathFilter->SetEndIndex(endPoint);
m_ShortestPathFilter->Update();
// construct contour from path image
//get the shortest path as vector
ShortestPathType shortestPath = m_ShortestPathFilter->GetVectorPath();
//fill the output contour with control points from the path
OutputType::Pointer output = dynamic_cast ( this->MakeOutput( 0 ).GetPointer() );
this->SetNthOutput(0, output.GetPointer());
// OutputType::Pointer output = dynamic_cast ( this->GetOutput() );
output->Expand(m_TimeStep+1);
// output->Clear();
mitk::Image::ConstPointer input = dynamic_cast(this->GetInput());
ShortestPathType::const_iterator pathIterator = shortestPath.begin();
while(pathIterator != shortestPath.end())
{
mitk::Point3D currentPoint;
currentPoint[0] = static_cast( (*pathIterator)[0] );
currentPoint[1] = static_cast( (*pathIterator)[1] );
currentPoint[2] = 0.0;
input->GetGeometry()->IndexToWorld(currentPoint, currentPoint);
output->AddVertex(currentPoint, false, m_TimeStep);
pathIterator++;
}
}
bool mitk::ImageLiveWireContourModelFilter::CreateDynamicCostMap(mitk::ContourModel* path)
{
mitk::Image::ConstPointer input = dynamic_cast(this->GetInput());
if(!input) return false;
try
{
AccessFixedDimensionByItk_1(input,CreateDynamicCostMapByITK, 2, path);
}
catch( itk::ExceptionObject & e )
{
MITK_INFO << "Exception caught during dynamic cost map alculation: " << e;
return false;
}
return true;
}
template
void mitk::ImageLiveWireContourModelFilter::CreateDynamicCostMapByITK( itk::Image* inputImage, mitk::ContourModel* path )
{
/*++++++++++ create dynamic cost transfer map ++++++++++*/
/* Compute the costs of the gradient magnitude dynamically.
* using a map of the histogram of gradient magnitude image.
* Use the histogram gradient map to interpolate the costs
* with gaussing function including next two bins right and left
* to current position x. With the histogram gradient costs are interpolated
* with a gaussing function summation of next two bins right and left
* to current position x.
*/
std::vector< itk::Index > shortestPath;
mitk::Image::ConstPointer input = dynamic_cast(this->GetInput());
if(path == NULL)
{
OutputType::Pointer output = this->GetOutput();
mitk::ContourModel::VertexIterator it = output->IteratorBegin();
while( it != output->IteratorEnd() )
{
itk::Index cur;
mitk::Point3D c = (*it)->Coordinates;
input->GetGeometry()->WorldToIndex(c, c);
cur[0] = c[0];
cur[1] = c[1];
shortestPath.push_back( cur);
it++;
}
}
else
{
mitk::ContourModel::VertexIterator it = path->IteratorBegin();
while( it != path->IteratorEnd() )
{
itk::Index cur;
mitk::Point3D c = (*it)->Coordinates;
input->GetGeometry()->WorldToIndex(c, c);
cur[0] = c[0];
cur[1] = c[1];
shortestPath.push_back( cur);
it++;
}
}
// filter image gradient magnitude
typedef itk::GradientMagnitudeImageFilter< itk::Image, itk::Image > GradientMagnitudeFilterType;
typename GradientMagnitudeFilterType::Pointer gradientFilter = GradientMagnitudeFilterType::New();
gradientFilter->SetInput(inputImage);
gradientFilter->Update();
typename itk::Image::Pointer gradientMagnImage = gradientFilter->GetOutput();
//get the path
//iterator of path
typename std::vector< itk::Index >::iterator pathIterator = shortestPath.begin();
std::map< int, int > histogram;
//create histogram within path
while(pathIterator != shortestPath.end())
{
//count pixel values
//use scale factor to avoid mapping gradients between 0.0 and 1.0 to same bin
histogram[ static_cast( gradientMagnImage->GetPixel((*pathIterator)) * ImageLiveWireContourModelFilter::CostFunctionType::MAPSCALEFACTOR ) ] += 1;
pathIterator++;
}
double max = 1.0;
if( !histogram.empty() )
{
std::map< int, int >::iterator itMAX;
//get max of histogramm
int currentMaxValue = 0;
std::map< int, int >::iterator it = histogram.begin();
while( it != histogram.end())
{
if((*it).second > currentMaxValue)
{
itMAX = it;
currentMaxValue = (*it).second;
}
it++;
}
std::map< int, int >::key_type keyOfMax = itMAX->first;
// compute the to max of gaussian summation
std::map< int, int >::iterator end = histogram.end();
std::map< int, int >::iterator last = --(histogram.end());
std::map< int, int >::iterator left2;
std::map< int, int >::iterator left1;
std::map< int, int >::iterator right1;
std::map< int, int >::iterator right2;
right1 = itMAX;
if(right1 == end || right1 == last )
{
right2 = end;
}
else//( right1 <= last )
{
std::map< int, int >::iterator temp = right1;
right2 = ++right1;//rght1 + 1
right1 = temp;
}
if( right1 == histogram.begin() )
{
left1 = end;
left2 = end;
}
else if( right1 == (++(histogram.begin())) )
{
std::map< int, int >::iterator temp = right1;
left1 = --right1;//rght1 - 1
right1 = temp;
left2 = end;
}
else
{
std::map< int, int >::iterator temp = right1;
left1 = --right1;//rght1 - 1
left2 = --right1;//rght1 - 2
right1 = temp;
}
double partRight1, partRight2, partLeft1, partLeft2;
partRight1 = partRight2 = partLeft1 = partLeft2 = 0.0;
/*
f(x) = v(bin) * e^ ( -1/2 * (|x-k(bin)| / sigma)^2 )
gaussian approximation
where
v(bin) is the value in the map
k(bin) is the key
*/
if( left2 != end )
{
partLeft2 = ImageLiveWireContourModelFilter::CostFunctionType::Gaussian(keyOfMax, left2->first, left2->second);
}
if( left1 != end )
{
partLeft1 = ImageLiveWireContourModelFilter::CostFunctionType::Gaussian(keyOfMax, left1->first, left1->second);
}
if( right1 != end )
{
partRight1 = ImageLiveWireContourModelFilter::CostFunctionType::Gaussian(keyOfMax, right1->first, right1->second);
}
if( right2 != end )
{
partRight2 = ImageLiveWireContourModelFilter::CostFunctionType::Gaussian(keyOfMax, right2->first, right2->second);
}
max = (partRight1 + partRight2 + partLeft1 + partLeft2);
}
this->m_CostFunction->SetDynamicCostMap(histogram);
this->m_CostFunction->SetCostMapMaximum(max);
}
diff --git a/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.h b/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.h
index d1fdb71fe6..8d546ecc8e 100644
--- a/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.h
+++ b/Modules/Segmentation/Algorithms/mitkImageLiveWireContourModelFilter.h
@@ -1,168 +1,166 @@
/*===================================================================
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 _mitkImageLiveWireContourModelFilter_h__
#define _mitkImageLiveWireContourModelFilter_h__
#include "mitkCommon.h"
#include "SegmentationExports.h"
#include "mitkContourModel.h"
#include "mitkContourModelSource.h"
#include
#include
#include
#include
#include
namespace mitk {
/**
\brief Calculates a LiveWire contour between two points in an image.
For defining costs between two pixels specific features are extraced from the image and tranformed into a single cost value.
\sa ShortestPathCostFunctionLiveWire
The filter is able to create dynamic cost tranfer map and thus use on the fly training.
\Note On the fly training will only be used for next update.
The computation uses the last calculated segment to map cost according to features in the area of the segment.
For time resolved purposes use ImageLiveWireContourModelFilter::SetTimestep( unsigned int ) to create the LiveWire contour
at a specific timestep.
\ingroup ContourModelFilters
\ingroup Process
*/
class Segmentation_EXPORT ImageLiveWireContourModelFilter : public ContourModelSource
{
public:
mitkClassMacro(ImageLiveWireContourModelFilter, ContourModelSource);
itkNewMacro(Self);
typedef ContourModel OutputType;
typedef OutputType::Pointer OutputTypePointer;
typedef mitk::Image InputType;
typedef itk::Image< float, 2 > InternalImageType;
typedef itk::ShortestPathImageFilter< InternalImageType, InternalImageType > ShortestPathImageFilterType;
typedef itk::ShortestPathCostFunctionLiveWire< InternalImageType > CostFunctionType;
typedef std::vector< itk::Index<2> > ShortestPathType;
/** \brief start point in world coordinates*/
itkSetMacro(StartPoint, mitk::Point3D);
itkGetMacro(StartPoint, mitk::Point3D);
/** \brief end point in woorld coordinates*/
itkSetMacro(EndPoint, mitk::Point3D);
itkGetMacro(EndPoint, mitk::Point3D);
/** \brief Create dynamic cost tranfer map - use on the fly training.
\Note On the fly training will be used for next update only.
The computation uses the last calculated segment to map cost according to features in the area of the segment.
*/
itkSetMacro(UseDynamicCostMap, bool);
itkGetMacro(UseDynamicCostMap, bool);
/** \brief Actual time step
*/
itkSetMacro(TimeStep, unsigned int);
itkGetMacro(TimeStep, unsigned int);
/** \brief Clear all repulsive points used in the cost function
*/
void ClearRepulsivePoints();
/** \brief Set a vector with repulsive points to use in the cost function
*/
void SetRepulsivePoints(const ShortestPathType& points);
/** \brief Add a single repulsive point to the cost function
*/
void AddRepulsivePoint( const itk::Index<2>& idx );
/** \brief Remove a single repulsive point from the cost function
*/
void RemoveRepulsivePoint( const itk::Index<2>& idx );
virtual void SetInput( const InputType *input);
virtual void SetInput( unsigned int idx, const InputType * input);
const InputType* GetInput(void);
const InputType* GetInput(unsigned int idx);
virtual OutputType* GetOutput();
+ virtual void DumpMaskImage();
/** \brief Create dynamic cost tranfer map - on the fly training*/
bool CreateDynamicCostMap(mitk::ContourModel* path=NULL);
protected:
ImageLiveWireContourModelFilter();
virtual ~ImageLiveWireContourModelFilter();
void GenerateOutputInformation() {};
void GenerateData();
void UpdateLiveWire();
/** \brief start point in worldcoordinates*/
mitk::Point3D m_StartPoint;
/** \brief end point in woorldcoordinates*/
mitk::Point3D m_EndPoint;
/** \brief Start point in index*/
mitk::Point3D m_StartPointInIndex;
/** \brief End point in index*/
mitk::Point3D m_EndPointInIndex;
/** \brief The cost function to compute costs between two pixels*/
CostFunctionType::Pointer m_CostFunction;
/** \brief Shortest path filter according to cost function m_CostFunction*/
ShortestPathImageFilterType::Pointer m_ShortestPathFilter;
/** \brief Flag to use a dynmic cost map or not*/
bool m_UseDynamicCostMap;
- /** \brief Flag to decide whether to run image pre-processing*/
- bool m_ImageModified;
-
unsigned int m_TimeStep;
template
void ItkPreProcessImage (itk::Image* inputImage);
template
void CreateDynamicCostMapByITK(itk::Image* inputImage, mitk::ContourModel* path=NULL);
InternalImageType::Pointer m_InternalImage;
};
}
#endif
diff --git a/Modules/Segmentation/Interactions/mitkContourModelInteractor.cpp b/Modules/Segmentation/Interactions/mitkContourModelInteractor.cpp
index bdb7e1a963..79c36baebc 100644
--- a/Modules/Segmentation/Interactions/mitkContourModelInteractor.cpp
+++ b/Modules/Segmentation/Interactions/mitkContourModelInteractor.cpp
@@ -1,281 +1,279 @@
/*===================================================================
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("ContourModelInteractor2", 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, OnFinishEditing );
}
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();
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::OnFinishEditing( Action* action, const StateEvent* stateEvent)
{
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 67ef96d0e7..28394b9a5d 100644
--- a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
+++ b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
@@ -1,434 +1,472 @@
/*===================================================================
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
+#include "mitkIOUtil.h"
mitk::ContourModelLiveWireInteractor::ContourModelLiveWireInteractor(DataNode* dataNode)
:ContourModelInteractor(dataNode)
{
+ CONNECT_ACTION( AcCLEAR, OnDumpImage ); // auxiliar for debug
m_LiveWireFilter = mitk::ImageLiveWireContourModelFilter::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() );
assert ( contour );
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(false);
m_lastMousePosition = click;
m_ContourLeft = mitk::ContourModel::New();
//get coordinates of next active vertex downwards from selected vertex
int downIndex = this->SplitContourFromSelectedVertex( contour, m_ContourLeft, false, timestep);
m_NextActiveVertexDownIter = contour->IteratorBegin() + downIndex;
m_NextActiveVertexDown = (*m_NextActiveVertexDownIter)->Coordinates;
m_ContourRight = mitk::ContourModel::New();
//get coordinates of next active vertex upwards from selected vertex
int upIndex = this->SplitContourFromSelectedVertex( contour, m_ContourRight, true, timestep);
m_NextActiveVertexUpIter = contour->IteratorBegin() + upIndex;
m_NextActiveVertexUp = (*m_NextActiveVertexUpIter)->Coordinates;
// clear previous void positions
this->m_LiveWireFilter->ClearRepulsivePoints();
// set the current contour as void positions in the cost map
// start with down side
mitk::ContourModel::VertexIterator iter = contour->IteratorBegin(timestep);
for (;iter != m_NextActiveVertexDownIter; iter++)
{
itk::Index<2> idx;
- this->m_WorkingImage->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
+ this->m_WorkingSlice->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
this->m_LiveWireFilter->AddRepulsivePoint( idx );
}
// continue with upper side
iter = m_NextActiveVertexUpIter + 1;
for (;iter != contour->IteratorEnd(timestep); iter++)
{
itk::Index<2> idx;
- this->m_WorkingImage->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
+ this->m_WorkingSlice->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
this->m_LiveWireFilter->AddRepulsivePoint( idx );
}
+ // clear container with void points between neighboring control points
+ m_ContourBeingModified.clear();
+
// let us have the selected point as a control point
contour->SetSelectedVertexAsControlPoint(true);
- // finally, allow for leave
+ // finally, allow to leave current state
newStateEvent = new mitk::StateEvent(EIDYES, stateEvent->GetEvent());
}
else
{
- // do not allow for leave
+ // do not allow to leave current state
newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
}
this->HandleEvent( newStateEvent );
assert( positionEvent->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
return true;
}
+void mitk::ContourModelLiveWireInteractor::SetWorkingImage (mitk::Image* _arg)
+{
+ if (this->m_WorkingSlice != _arg)
+ {
+ this->m_WorkingSlice = _arg;
+ this->m_LiveWireFilter->SetInput(this->m_WorkingSlice);
+ this->Modified();
+ }
+}
+
+bool mitk::ContourModelLiveWireInteractor::OnDumpImage( Action* action, const StateEvent* stateEvent)
+{
+ this->m_LiveWireFilter->DumpMaskImage();
+ mitk::IOUtil::SaveImage(this->m_WorkingSlice, "G:\\Data\\slice.nrrd");
+
+ 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() );
assert ( contour );
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( this->m_NextActiveVertexDown );
this->m_LiveWireFilter->SetEndPoint( this->m_NextActiveVertexUp );
- this->m_LiveWireFilter->ClearRepulsivePoints();
+ // this->m_LiveWireFilter->ClearRepulsivePoints();
this->m_LiveWireFilter->Update();
mitk::ContourModel *liveWireContour = this->m_LiveWireFilter->GetOutput();
assert ( liveWireContour );
if ( liveWireContour->IsEmpty(timestep) )
return false;
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->SetIsClosed(contour->IsClosed(timestep), timestep);
m_DataNode->SetData(newContour);
assert( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
return true;
}
return false;
}
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::Point3D currentPosition = positionEvent->GetWorldPosition();
mitk::ContourModel *contour = dynamic_cast( m_DataNode->GetData() );
assert ( contour );
// 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 from the last portion of the contour that was modified, i.e. between
- // previous active vertex and next active vertex.
+ // remove void positions between previous active vertex and next active vertex.
if (!m_ContourBeingModified.empty())
{
- std::vector< itk::Index< 2 > >::const_iterator msIter = m_ContourBeingModified.begin();
- for (;msIter != m_ContourBeingModified.end(); msIter++)
+ std::vector< itk::Index< 2 > >::const_iterator iter = m_ContourBeingModified.begin();
+ for (;iter != m_ContourBeingModified.end(); iter++)
{
- this->m_LiveWireFilter->RemoveRepulsivePoint( (*msIter) );
+ 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->GetNumberOfVertices(timestep) > 1.5*m_EditingSize )
+ // return false;
+
if ( !leftLiveWire->IsEmpty(timestep) )
leftLiveWire->RemoveVertexAt(0, timestep);
// at this point the container has to be empty
m_ContourBeingModified.clear();
- // add points from already calculated left live wire contour
+ // add points from left live wire contour
mitk::ContourModel::VertexIterator iter = leftLiveWire->IteratorBegin(timestep);
for (;iter != leftLiveWire->IteratorEnd(timestep); iter++)
{
itk::Index<2> idx;
- this->m_WorkingImage->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
+ this->m_WorkingSlice->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
this->m_LiveWireFilter->AddRepulsivePoint( idx );
- // keep points from left live wire contour
+ // 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 )
+ {
+ MITK_INFO << "reject strange path";
+ return false;
+ }
+*/
if ( !rightLiveWire->IsEmpty(timestep) )
rightLiveWire->RemoveVertexAt(0, timestep);
if ( !leftLiveWire->IsEmpty(timestep) )
leftLiveWire->SetControlVertexAt(leftLiveWire->GetNumberOfVertices()-1, timestep);
- //leftLiveWire->SelectVertexAt(leftLiveWire->GetNumberOfVertices()-1, timestep);
// set corrected left live wire to its node
m_LeftLiveWireContourNode->SetData(leftLiveWire);
// set corrected right live wire to its node
m_RightLiveWireContourNode->SetData(rightLiveWire);
+// not really needed
+/*
+ // add points from right live wire contour
iter = rightLiveWire->IteratorBegin(timestep);
for (;iter != rightLiveWire->IteratorEnd(timestep); iter++)
{
itk::Index<2> idx;
- this->m_WorkingImage->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
- // keep points from right live wire contour
+ this->m_WorkingSlice->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
+ this->m_LiveWireFilter->AddRepulsivePoint( idx );
+ // add indices
m_ContourBeingModified.push_back(idx);
}
+*/
mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
newContour->Expand(contour->GetTimeSteps());
// concatenate left original contour
newContour->Concatenate( this->m_ContourLeft, timestep );
newContour->Deselect();
- // concatenate left live wire
- newContour->Concatenate( leftLiveWire, timestep );
+ // concatenate left live wire but only if we have more than one vertex
+ if (leftLiveWire->GetNumberOfVertices(timestep)>1)
+ newContour->Concatenate( leftLiveWire, timestep );
// set last inserted vertex as selected
newContour->SelectVertexAt(newContour->GetNumberOfVertices()-1, timestep);
- // concatenate right live wire
- newContour->Concatenate( rightLiveWire, timestep );
+ // concatenate right live wire but only if we have more than one vertex
+ if (rightLiveWire->GetNumberOfVertices(timestep)>1)
+ newContour->Concatenate( rightLiveWire, timestep );
// concatenate right original contour
newContour->Concatenate( this->m_ContourRight, timestep );
newContour->SetIsClosed(contour->IsClosed(timestep), timestep);
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* srcContour,
mitk::ContourModel* destContour,
bool fromSelectedUpwards, int timestep)
{
mitk::ContourModel::VertexIterator end = srcContour->IteratorEnd();
mitk::ContourModel::VertexIterator begin = srcContour->IteratorBegin();
//search next active control point to left and rigth and set as start and end point for filter
mitk::ContourModel::VertexIterator itSelected = begin;
// move iterator to position
while ((*itSelected) != srcContour->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 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)
{
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
{
mitk::ContourModel::VertexIterator itDown = itSelected;
mitk::ContourModel::VertexIterator 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--;}
//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;
}
}
}
bool mitk::ContourModelLiveWireInteractor::OnFinishEditing( Action* action, const StateEvent* stateEvent)
{
int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
mitk::ContourModel *leftLiveWire = dynamic_cast( this->m_LeftLiveWireContourNode->GetData() );
assert ( leftLiveWire );
leftLiveWire->Clear(timestep);
mitk::ContourModel *rightLiveWire = dynamic_cast( this->m_RightLiveWireContourNode->GetData() );
assert ( rightLiveWire );
rightLiveWire->Clear(timestep);
assert( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
return true;
}
diff --git a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.h b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.h
index 7d85023cdc..e2666a3993 100644
--- a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.h
+++ b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.h
@@ -1,107 +1,99 @@
/*===================================================================
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 mitkContourModelLiveWireInteractor_h_Included
#define mitkContourModelLiveWireInteractor_h_Included
#include "mitkCommon.h"
#include "SegmentationExports.h"
#include "mitkContourModelInteractor.h"
#include
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 Segmentation_EXPORT ContourModelLiveWireInteractor : public ContourModelInteractor
{
public:
mitkClassMacro(ContourModelLiveWireInteractor, ContourModelInteractor);
mitkNewMacro1Param(Self, DataNode*);
virtual void SetLeftLiveWireContourModelNode (mitk::DataNode* _arg)
{
this->m_LeftLiveWireContourNode = _arg;
this->Modified();
}
virtual void SetRightLiveWireContourModelNode (mitk::DataNode* _arg)
{
this->m_RightLiveWireContourNode = _arg;
this->Modified();
}
- virtual void SetWorkingImage (mitk::Image* _arg)
- {
- if (this->m_WorkingImage != _arg)
- {
- this->m_WorkingImage = _arg;
- this->m_LiveWireFilter->SetInput(this->m_WorkingImage);
- this->Modified();
- }
- }
+ virtual void SetWorkingImage (mitk::Image* _arg);
protected:
ContourModelLiveWireInteractor(DataNode* dataNode);
virtual ~ContourModelLiveWireInteractor();
-
+ virtual bool OnDumpImage(Action*, const StateEvent*);
virtual bool OnDeletePoint(Action*, const StateEvent*);
virtual bool OnMovePoint(Action*, const StateEvent*);
virtual bool OnCheckPointClick( Action* action, const StateEvent* stateEvent);
virtual bool OnFinishEditing( Action* action, const StateEvent* stateEvent);
int SplitContourFromSelectedVertex(mitk::ContourModel* srcContour,
mitk::ContourModel* destContour,
bool fromSelectedUpwards,
int timestep);
mitk::ImageLiveWireContourModelFilter::Pointer m_LiveWireFilter;
- mitk::Image::Pointer m_WorkingImage;
+ 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_LeftLiveWireContourNode;
mitk::DataNode::Pointer m_RightLiveWireContourNode;
mitk::ContourModel::Pointer m_ContourLeft;
mitk::ContourModel::Pointer m_ContourRight;
};
} // namespace mitk
#endif // mitkContourModelLiveWireInteractor_h_Included
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
index dc1e1b7809..fef9e536bf 100644
--- a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
@@ -1,638 +1,633 @@
/*===================================================================
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 "mitkLiveWireTool2D.h"
#include "mitkToolManager.h"
#include "mitkBaseRenderer.h"
#include "mitkRenderingManager.h"
#include "mitkLiveWireTool2D.xpm"
#include
#include
#include "mitkContourUtils.h"
#include "mitkContour.h"
#include
namespace mitk {
MITK_TOOL_MACRO(Segmentation_EXPORT, LiveWireTool2D, "LiveWire tool");
}
mitk::LiveWireTool2D::LiveWireTool2D()
:SegTool2D("LiveWireTool")
{
// great magic numbers
CONNECT_ACTION( AcINITNEWOBJECT, OnInitLiveWire );
CONNECT_ACTION( AcADDPOINT, OnAddPoint );
CONNECT_ACTION( AcMOVE, OnMouseMoveNoDynamicCosts );
CONNECT_ACTION( AcCHECKPOINT, OnCheckPoint );
CONNECT_ACTION( AcFINISH, OnFinish );
CONNECT_ACTION( AcDELETEPOINT, OnLastSegmentDelete );
CONNECT_ACTION( AcADDLINE, OnMouseMoved );
}
mitk::LiveWireTool2D::~LiveWireTool2D()
{
m_Contours.clear();
}
float mitk::LiveWireTool2D::CanHandleEvent( StateEvent const *stateEvent) const
{
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.0;
}
}
else
{
if ( positionEvent->GetSender()->GetMapperID() != BaseRenderer::Standard2D )
return 0.0; // we don't want anything but 2D
return 1.0;
}
}
const char** mitk::LiveWireTool2D::GetXPM() const
{
return mitkLiveWireTool2D_xpm;
}
const char* mitk::LiveWireTool2D::GetName() const
{
return "LiveWire";
}
void mitk::LiveWireTool2D::Activated()
{
Superclass::Activated();
}
void mitk::LiveWireTool2D::Deactivated()
{
// this->FinishTool();
//add interactor to globalInteraction instance
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_LiveWireInteractor);
DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
if ( !workingNode ) return;
Image* workingImage = dynamic_cast(workingNode->GetData());
if ( !workingImage ) return;
ContourUtils::Pointer contourUtils = mitk::ContourUtils::New();
// for all contours in list (currently created by tool)
std::vector< std::pair >::iterator it = m_Contours.begin();
while(it != m_Contours.end() )
{
// if node contains data
if( it->first->GetData() )
{
// if this is a contourModel
mitk::ContourModel* contourModel = dynamic_cast(it->first->GetData());
if( contourModel )
{
//++++++++++++++++++++++ for each timestep of this contourModel
for( int currentTimestep = 0; currentTimestep < contourModel->GetTimeSlicedGeometry()->GetTimeSteps(); currentTimestep++)
{
//get the segmentation image slice at current timestep
mitk::Image::Pointer workingSlice = this->GetAffectedImageSliceAs2DImage(it->second, workingImage, currentTimestep);
// transfer to plain old contour to use contour util functionality
mitk::Contour::Pointer plainOldContour = mitk::Contour::New();
mitk::ContourModel::VertexIterator iter = contourModel->IteratorBegin(currentTimestep);
while(iter != contourModel->IteratorEnd(currentTimestep) )
{
plainOldContour->AddVertex( (*iter)->Coordinates );
iter++;
}
mitk::Contour::Pointer projectedContour = contourUtils->ProjectContourTo2DSlice(workingSlice, plainOldContour, true, false);
contourUtils->FillContourInSlice(projectedContour, workingSlice, 1.0);
//write back to image volume
this->WriteBackSegmentationResult(it->second, workingSlice, currentTimestep);
}
//remove contour node from datastorage
m_ToolManager->GetDataStorage()->Remove( it->first );
}
}
++it;
}
m_Contours.clear();
m_ToolManager->GetDataStorage()->Remove( m_LeftLiveWireContourNode );
m_ToolManager->GetDataStorage()->Remove( m_RightLiveWireContourNode );
m_LeftLiveWireContourNode = NULL;
m_LeftLiveWireContour = NULL;
m_RightLiveWireContourNode = NULL;
m_RightLiveWireContour = NULL;
Superclass::Deactivated();
}
bool mitk::LiveWireTool2D::OnInitLiveWire (Action* action, const StateEvent* stateEvent)
{
const PositionEvent* positionEvent = dynamic_cast(stateEvent->GetEvent());
if (!positionEvent) return false;
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
int timestep = positionEvent->GetSender()->GetTimeStep();
m_Contour = mitk::ContourModel::New();
m_Contour->Expand(timestep+1);
m_ContourModelNode = mitk::DataNode::New();
m_ContourModelNode->SetData( m_Contour );
m_ContourModelNode->SetName("working contour node");
m_ContourModelNode->AddProperty( "contour.color", ColorProperty::New(1, 1, 0), NULL, true );
m_ContourModelNode->AddProperty( "contour.points.color", ColorProperty::New(1.0, 0.0, 0.1), NULL, true );
m_ContourModelNode->AddProperty( "contour.controlpoints.show", BoolProperty::New(true), NULL, true );
m_LiveWireContour = mitk::ContourModel::New();
m_LiveWireContour->Expand(timestep+1);
m_LiveWireContourNode = mitk::DataNode::New();
m_LiveWireContourNode->SetData( m_LiveWireContour );
m_LiveWireContourNode->SetName("active livewire node");
m_LiveWireContourNode->AddProperty( "contour.color", ColorProperty::New(0.1, 1.0, 0.1), NULL, true );
m_LiveWireContourNode->AddProperty( "contour.width", mitk::FloatProperty::New( 4.0 ), NULL, true );
m_LeftLiveWireContour = mitk::ContourModel::New();
m_LeftLiveWireContour->Expand(timestep+1);
m_LeftLiveWireContourNode = mitk::DataNode::New();
m_LeftLiveWireContourNode->SetData( m_LeftLiveWireContour );
m_LeftLiveWireContourNode->SetName("left node");
m_LeftLiveWireContourNode->AddProperty( "contour.color", ColorProperty::New(0.1, 1.0, 0.1), NULL, true );
m_LeftLiveWireContourNode->AddProperty( "contour.points.color", ColorProperty::New(0.0, 0.0, 1.0), NULL, true );
m_LeftLiveWireContourNode->AddProperty( "contour.width", mitk::FloatProperty::New( 4.0 ), NULL, true );
m_RightLiveWireContour = mitk::ContourModel::New();
m_RightLiveWireContour->Expand(timestep+1);
m_RightLiveWireContourNode = mitk::DataNode::New();
m_RightLiveWireContourNode->SetData( m_RightLiveWireContour );
m_RightLiveWireContourNode->SetName("right node");
m_RightLiveWireContourNode->AddProperty( "contour.color", ColorProperty::New(0.1, 1.0, 0.1), NULL, true );
m_RightLiveWireContourNode->AddProperty( "contour.width", mitk::FloatProperty::New( 4.0 ), NULL, true );
m_ToolManager->GetDataStorage()->Add( m_ContourModelNode );
m_ToolManager->GetDataStorage()->Add( m_LiveWireContourNode );
m_ToolManager->GetDataStorage()->Add( m_RightLiveWireContourNode );
m_ToolManager->GetDataStorage()->Add( m_LeftLiveWireContourNode );
//set current slice as input for ImageToLiveWireContourFilter
m_WorkingSlice = this->GetAffectedReferenceSlice(positionEvent);
m_LiveWireFilter = mitk::ImageLiveWireContourModelFilter::New();
m_LiveWireFilter->SetInput(m_WorkingSlice);
//map click to pixel coordinates
mitk::Point3D click = const_cast(positionEvent->GetWorldPosition());
itk::Index<3> idx;
m_WorkingSlice->GetGeometry()->WorldToIndex(click, idx);
// get the pixel the gradient in region of 5x5
itk::Index<3> indexWithHighestGradient;
AccessFixedDimensionByItk_2(m_WorkingSlice, FindHighestGradientMagnitudeByITK, 2, idx, indexWithHighestGradient);
// itk::Index to mitk::Point3D
click[0] = indexWithHighestGradient[0];
click[1] = indexWithHighestGradient[1];
click[2] = indexWithHighestGradient[2];
m_WorkingSlice->GetGeometry()->IndexToWorld(click, click);
//set initial start point
m_Contour->AddVertex( click, true, timestep );
m_LiveWireFilter->SetStartPoint(click);
m_CreateAndUseDynamicCosts = true;
//render
assert( positionEvent->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
return true;
}
bool mitk::LiveWireTool2D::OnAddPoint (Action* action, const StateEvent* stateEvent)
{
//complete LiveWire interaction for last segment
//add current LiveWire contour to the finished contour and reset
//to start new segment and computation
/* check if event can be handled */
const PositionEvent* positionEvent = dynamic_cast(stateEvent->GetEvent());
if (!positionEvent) return false;
if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
/* END check if event can be handled */
-
int timestep = positionEvent->GetSender()->GetTimeStep();
- // we clear here all previous repulsive points but it would be better to keep them
- // so that the calculated live wire does not intersect any part of the working contour
- //m_LiveWireFilter->ClearRepulsivePoints();
-
typedef mitk::ImageLiveWireContourModelFilter::InternalImageType::IndexType IndexType;
mitk::ContourModel::ConstVertexIterator iter = m_LiveWireContour->IteratorBegin(timestep);
for (;iter != m_LiveWireContour->IteratorEnd(timestep); iter++)
{
IndexType idx;
this->m_WorkingSlice->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
this->m_LiveWireFilter->AddRepulsivePoint( idx );
}
this->m_LiveWireFilter->Update();
//remove duplicate first vertex, it's already contained in m_Contour
m_LiveWireContour->RemoveVertexAt(0, timestep);
// set last added point as control point
m_LiveWireContour->SetControlVertexAt(m_LiveWireContour->GetNumberOfVertices(timestep)-1, timestep);
//merge contours
m_Contour->Concatenate(m_LiveWireContour, timestep);
//clear the livewire contour and reset the corresponding datanode
m_LiveWireContour->Clear(timestep);
//set new start point
m_LiveWireFilter->SetStartPoint(const_cast(positionEvent->GetWorldPosition()));
if( m_CreateAndUseDynamicCosts )
{
//use dynamic cost map for next update
m_LiveWireFilter->CreateDynamicCostMap(m_Contour);
m_LiveWireFilter->SetUseDynamicCostMap(true);
//m_CreateAndUseDynamicCosts = false;
}
//render
assert( positionEvent->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
return true;
}
bool mitk::LiveWireTool2D::OnMouseMoved( Action* action, const StateEvent* stateEvent)
{
//compute LiveWire segment from last control point to current mouse position
// check if event can be handled
if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
const PositionEvent* positionEvent = dynamic_cast(stateEvent->GetEvent());
if (!positionEvent) return false;
// actual LiveWire computation
int timestep = positionEvent->GetSender()->GetTimeStep();
m_LiveWireFilter->SetEndPoint(const_cast(positionEvent->GetWorldPosition()));
m_LiveWireFilter->SetTimeStep(m_TimeStep);
m_LiveWireFilter->Update();
m_LiveWireContour = this->m_LiveWireFilter->GetOutput();
m_LiveWireContourNode->SetData( this->m_LiveWireContour );
//render
assert( positionEvent->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
return true;
}
bool mitk::LiveWireTool2D::OnMouseMoveNoDynamicCosts(Action* action, const StateEvent* stateEvent)
{
//do not use dynamic cost map
m_LiveWireFilter->SetUseDynamicCostMap(false);
OnMouseMoved(action, stateEvent);
m_LiveWireFilter->SetUseDynamicCostMap(true);
return true;
}
bool mitk::LiveWireTool2D::OnCheckPoint( Action* action, const StateEvent* stateEvent)
{
//check double click on first control point to finish the LiveWire tool
//
//Check distance to first point.
//Transition YES if click close to first control point
//
mitk::StateEvent* newStateEvent = NULL;
const PositionEvent* positionEvent = dynamic_cast(stateEvent->GetEvent());
if (!positionEvent)
{
//stay in current state
newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
}
else
{
int timestep = positionEvent->GetSender()->GetTimeStep();
mitk::Point3D click = positionEvent->GetWorldPosition();
mitk::Point3D first = this->m_Contour->GetVertexAt(0, timestep)->Coordinates;
if (first.EuclideanDistanceTo(click) < 4.5)
{
// allow to finish
newStateEvent = new mitk::StateEvent(EIDYES, stateEvent->GetEvent());
}
else
{
//stay active
newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
}
}
this->HandleEvent( newStateEvent );
return true;
}
bool mitk::LiveWireTool2D::OnFinish( Action* action, const StateEvent* stateEvent)
{
// finish livewire tool interaction
// check if event can be handled
if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
const PositionEvent* positionEvent = dynamic_cast(stateEvent->GetEvent());
if (!positionEvent) return false;
// actual timestep
int timestep = positionEvent->GetSender()->GetTimeStep();
// remove last control point being added by double click
m_Contour->RemoveVertexAt(m_Contour->GetNumberOfVertices(timestep) - 1, timestep);
// save contour and corresponding plane geometry to list
std::pair contourPair(m_ContourModelNode.GetPointer(), dynamic_cast(positionEvent->GetSender()->GetCurrentWorldGeometry2D()->Clone().GetPointer()) );
m_Contours.push_back(contourPair);
m_LiveWireFilter->SetUseDynamicCostMap(false);
this->FinishTool();
return true;
}
void mitk::LiveWireTool2D::FinishTool()
{
unsigned int numberOfTimesteps = m_Contour->GetTimeSlicedGeometry()->GetTimeSteps();
//close contour in each timestep
for( int i = 0; i <= numberOfTimesteps; i++)
{
m_Contour->Close(i);
}
m_ToolManager->GetDataStorage()->Remove( m_LiveWireContourNode );
// clear live wire contour node
m_LiveWireContourNode = NULL;
m_LiveWireContour = NULL;
//TODO visual feedback for completing livewire tool
m_ContourModelNode->AddProperty( "contour.color", ColorProperty::New(1.0, 1.0, 0.1), NULL, true );
m_ContourModelNode->SetName("contour node");
//set the livewire interactor to edit control points
m_LiveWireInteractor = mitk::ContourModelLiveWireInteractor::New(m_ContourModelNode);
m_LiveWireInteractor->SetWorkingImage(this->m_WorkingSlice);
m_LiveWireInteractor->SetRightLiveWireContourModelNode(this->m_RightLiveWireContourNode);
m_LiveWireInteractor->SetLeftLiveWireContourModelNode(this->m_LeftLiveWireContourNode);
m_ContourModelNode->SetInteractor(m_LiveWireInteractor);
//add interactor to globalInteraction instance
mitk::GlobalInteraction::GetInstance()->AddInteractor(m_LiveWireInteractor);
}
bool mitk::LiveWireTool2D::OnLastSegmentDelete( Action* action, const StateEvent* stateEvent)
{
int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
//if last point of current contour will be removed go to start state and remove nodes
if( m_Contour->GetNumberOfVertices(timestep) <= 1 )
{
m_ToolManager->GetDataStorage()->Remove( m_LiveWireContourNode );
m_ToolManager->GetDataStorage()->Remove( m_ContourModelNode );
m_LiveWireContour = mitk::ContourModel::New();
m_Contour = mitk::ContourModel::New();
m_ContourModelNode->SetData( m_Contour );
m_LiveWireContourNode->SetData( m_LiveWireContour );
Superclass::Deactivated(); //go to start state
}
else //remove last segment from contour and reset livewire contour
{
m_LiveWireContour = mitk::ContourModel::New();
m_LiveWireContourNode->SetData(m_LiveWireContour);
mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
newContour->Expand(m_Contour->GetTimeSteps());
mitk::ContourModel::VertexIterator begin = m_Contour->IteratorBegin();
//iterate from last point to next active point
mitk::ContourModel::VertexIterator newLast = m_Contour->IteratorBegin() + (m_Contour->GetNumberOfVertices() - 1);
//go at least one down
if(newLast != begin)
{
newLast--;
}
//search next active control point
while(newLast != begin && !((*newLast)->IsControlPoint) )
{
newLast--;
}
//set position of start point for livewire filter to coordinates of the new last point
m_LiveWireFilter->SetStartPoint((*newLast)->Coordinates);
mitk::ContourModel::VertexIterator it = m_Contour->IteratorBegin();
//fill new Contour
while(it <= newLast)
{
newContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timestep);
it++;
}
newContour->SetIsClosed(m_Contour->IsClosed());
//set new contour visible
m_ContourModelNode->SetData(newContour);
m_Contour = newContour;
assert( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
}
return true;
}
template
void mitk::LiveWireTool2D::FindHighestGradientMagnitudeByITK(itk::Image* inputImage, itk::Index<3> &index, itk::Index<3> &returnIndex)
{
typedef itk::Image InputImageType;
typedef typename InputImageType::IndexType IndexType;
unsigned long xMAX = inputImage->GetLargestPossibleRegion().GetSize()[0];
unsigned long yMAX = inputImage->GetLargestPossibleRegion().GetSize()[1];
returnIndex[0] = index[0];
returnIndex[1] = index[1];
returnIndex[2] = 0.0;
double gradientMagnitude = 0.0;
double maxGradientMagnitude = 0.0;
/*
the size and thus the region of 7x7 is only used to calculate the gradient magnitude in that region
not for searching the maximum value
*/
//maximum value in each direction for size
typename InputImageType::SizeType size;
size[0] = 7;
size[1] = 7;
//minimum value in each direction for startRegion
IndexType startRegion;
startRegion[0] = index[0] - 3;
startRegion[1] = index[1] - 3;
if(startRegion[0] < 0) startRegion[0] = 0;
if(startRegion[1] < 0) startRegion[1] = 0;
if(xMAX - index[0] < 7) startRegion[0] = xMAX - 7;
if(yMAX - index[1] < 7) startRegion[1] = yMAX - 7;
index[0] = startRegion[0] + 3;
index[1] = startRegion[1] + 3;
typename InputImageType::RegionType region;
region.SetSize( size );
region.SetIndex( startRegion );
typedef typename itk::GradientMagnitudeImageFilter< InputImageType, InputImageType> GradientMagnitudeFilterType;
typename GradientMagnitudeFilterType::Pointer gradientFilter = GradientMagnitudeFilterType::New();
gradientFilter->SetInput(inputImage);
gradientFilter->GetOutput()->SetRequestedRegion(region);
gradientFilter->Update();
typename InputImageType::Pointer gradientMagnImage;
gradientMagnImage = gradientFilter->GetOutput();
IndexType currentIndex;
currentIndex[0] = 0;
currentIndex[1] = 0;
// search max (approximate) gradient magnitude
for( int x = -1; x <= 1; ++x)
{
currentIndex[0] = index[0] + x;
for( int y = -1; y <= 1; ++y)
{
currentIndex[1] = index[1] + y;
gradientMagnitude = gradientMagnImage->GetPixel(currentIndex);
//check for new max
if(maxGradientMagnitude < gradientMagnitude)
{
maxGradientMagnitude = gradientMagnitude;
returnIndex[0] = currentIndex[0];
returnIndex[1] = currentIndex[1];
returnIndex[2] = 0.0;
}//end if
}//end for y
currentIndex[1] = index[1];
}//end for x
}