mitk::ImageToLiveWireContourFilter::ImageToLiveWireContourFilter()
{
OutputType::Pointer output = dynamic_cast<OutputType*> ( this->MakeOutput( 0 ).GetPointer() );
this->SetNumberOfRequiredInputs(1);
this->SetNumberOfIndexedOutputs( 1 );
this->SetNthOutput(0, output.GetPointer());
}
mitk::ContourSetToPointSetFilter::ContourSetToPointSetFilter()
{
OutputType::Pointer output = dynamic_cast<OutputType*> ( this->MakeOutput( 0 ).GetPointer() );
this->SetNumberOfRequiredInputs(1);
this->SetNumberOfIndexedOutputs( 1 );
this->SetNthOutput(0, output.GetPointer());
m_Frequency = 5;
}
mitk::ContourModelSubDivisionFilter::ContourModelSubDivisionFilter()
{
OutputType::Pointer output = dynamic_cast<OutputType *>(this->MakeOutput(0).GetPointer());
this->SetNumberOfRequiredInputs(1);
this->SetNumberOfIndexedOutputs(1);
this->SetNthOutput(0, output.GetPointer());
this->m_InterpolationIterations = 4;
}
mitk::DataNodeSource::DataNodeSource()
{
// Create the output.
OutputType::Pointer output = dynamic_cast<OutputType*> ( this->MakeOutput( 0 ).GetPointer() );
assert (output.IsNotNull());
this->SetNumberOfOutputs( 1 );
this->SetOutput(0, output.GetPointer());
}
mitk::PointSetSource::PointSetSource()
{
// Create the output.
OutputType::Pointer output = dynamic_cast<OutputType*>(this->MakeOutput(0).GetPointer());
Superclass::SetNumberOfRequiredInputs(0);
Superclass::SetNumberOfRequiredOutputs(1);
Superclass::SetNthOutput(0, output.GetPointer());
}
mitk::ImageLiveWireContourModelFilter::ImageLiveWireContourModelFilter()
{
OutputType::Pointer output = dynamic_cast<OutputType*> ( 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_TimeStep = 0;
}
std::vector<itk::SmartPointer<BaseData> > NrrdTensorImageReader::Read()
{
std::vector<itk::SmartPointer<mitk::BaseData> > result;
std::string location = GetInputLocation();
if ( location == "")
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename is empty!");
}
else
{
try
{
mitk::LocaleSwitch localeSwitch("C");
try
{
std::string fname3 = mitk::IOUtil::GetTempPath()+"/temp_dti.nii.gz";
int c = 0;
while( itksys::SystemTools::FileExists(fname3) )
{
fname3 = mitk::IOUtil::GetTempPath()+"/temp_dti_" + boost::lexical_cast<std::string>(c) + ".nii.gz";
++c;
}
itksys::SystemTools::CopyAFile(location.c_str(), fname3.c_str());
typedef itk::VectorImage<float,3> ImageType;
itk::NiftiImageIO::Pointer io = itk::NiftiImageIO::New();
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetImageIO(io);
reader->SetFileName(fname3);
reader->Update();
ImageType::Pointer img = reader->GetOutput();
TensorImage::ItkTensorImageType::Pointer vecImg = TensorImage::ItkTensorImageType::New();
vecImg->SetSpacing( img->GetSpacing() ); // Set the image spacing
vecImg->SetOrigin( img->GetOrigin() ); // Set the image origin
vecImg->SetDirection( img->GetDirection() ); // Set the image direction
vecImg->SetRegions( img->GetLargestPossibleRegion());
vecImg->Allocate();
itk::ImageRegionIterator<TensorImage::ItkTensorImageType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
ot.GoToBegin();
itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
it.GoToBegin();
typedef ImageType::PixelType VarPixType;
typedef TensorImage::PixelType FixPixType;
int numComponents = img->GetNumberOfComponentsPerPixel();
if (numComponents==6)
{
MITK_INFO << "Trying to load dti as 6-comp nifti ...";
while (!it.IsAtEnd())
{
VarPixType vec = it.Get();
FixPixType fixVec(vec.GetDataPointer());
TensorImage::PixelType tensor;
tensor.SetElement(0, vec.GetElement(0));
tensor.SetElement(1, vec.GetElement(1));
tensor.SetElement(2, vec.GetElement(2));
tensor.SetElement(3, vec.GetElement(3));
tensor.SetElement(4, vec.GetElement(4));
tensor.SetElement(5, vec.GetElement(5));
fixVec = tensor;
ot.Set(fixVec);
++ot;
++it;
}
}
else if(numComponents==9)
{
MITK_INFO << "Trying to load dti as 9-comp nifti ...";
while (!it.IsAtEnd())
{
VarPixType vec = it.Get();
TensorImage::PixelType tensor;
tensor.SetElement(0, vec.GetElement(0));
tensor.SetElement(1, vec.GetElement(1));
tensor.SetElement(2, vec.GetElement(2));
tensor.SetElement(3, vec.GetElement(4));
tensor.SetElement(4, vec.GetElement(5));
tensor.SetElement(5, vec.GetElement(8));
FixPixType fixVec(tensor);
ot.Set(fixVec);
++ot;
++it;
}
}
else if (numComponents==1)
{
MITK_INFO << "Trying to load dti as 4D nifti ...";
typedef itk::Image<float,4> ImageType;
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetImageIO(io);
reader->SetFileName(fname3);
reader->Update();
ImageType::Pointer img = reader->GetOutput();
itk::Size<4> size = img->GetLargestPossibleRegion().GetSize();
while (!ot.IsAtEnd())
{
TensorImage::PixelType tensor;
ImageType::IndexType idx;
idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2];
if (size[3]==6)
{
for (unsigned int te=0; te<size[3]; te++)
{
idx[3] = te;
tensor.SetElement(te, img->GetPixel(idx));
}
}
else if (size[3]==9)
{
idx[3] = 0;
tensor.SetElement(0, img->GetPixel(idx));
idx[3] = 1;
tensor.SetElement(1, img->GetPixel(idx));
idx[3] = 2;
tensor.SetElement(2, img->GetPixel(idx));
idx[3] = 4;
tensor.SetElement(3, img->GetPixel(idx));
idx[3] = 5;
tensor.SetElement(4, img->GetPixel(idx));
idx[3] = 8;
tensor.SetElement(5, img->GetPixel(idx));
}
else
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Unknown number of components for DTI file. Should be 6 or 9!");
FixPixType fixVec(tensor);
ot.Set(fixVec);
++ot;
}
}
OutputType::Pointer resultImage = OutputType::New();
resultImage->InitializeByItk( vecImg.GetPointer() );
resultImage->SetVolume( vecImg->GetBufferPointer() );
result.push_back( resultImage.GetPointer() );
}
catch(...)
{
MITK_INFO << "Trying to load dti as nrrd ...";
typedef itk::VectorImage<float,3> ImageType;
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetImageIO(io);
reader->SetFileName(location);
reader->Update();
ImageType::Pointer img = reader->GetOutput();
TensorImage::ItkTensorImageType::Pointer vecImg = TensorImage::ItkTensorImageType::New();
vecImg->SetSpacing( img->GetSpacing() ); // Set the image spacing
vecImg->SetOrigin( img->GetOrigin() ); // Set the image origin
vecImg->SetDirection( img->GetDirection() ); // Set the image direction
vecImg->SetRegions( img->GetLargestPossibleRegion());
vecImg->Allocate();
itk::ImageRegionIterator<TensorImage::ItkTensorImageType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
ot.GoToBegin();
itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
it.GoToBegin();
typedef ImageType::PixelType VarPixType;
typedef TensorImage::PixelType FixPixType;
int numComponents = img->GetNumberOfComponentsPerPixel();
itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
std::string metaString;
bool readFrame = false;
double xx, xy, xz, yx, yy, yz, zx, zy, zz;
MeasurementFrameType measFrame;
measFrame.SetIdentity();
MeasurementFrameType measFrameTransp;
measFrameTransp.SetIdentity();
for (; itKey != imgMetaKeys.end(); itKey ++)
{
itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
if (itKey->find("measurement frame") != std::string::npos)
{
sscanf(metaString.c_str(), " ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) \n", &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz);
if (xx>10e-10 || xy>10e-10 || xz>10e-10 ||
yx>10e-10 || yy>10e-10 || yz>10e-10 ||
zx>10e-10 || zy>10e-10 || zz>10e-10 )
{
readFrame = true;
measFrame(0,0) = xx;
measFrame(0,1) = xy;
measFrame(0,2) = xz;
measFrame(1,0) = yx;
measFrame(1,1) = yy;
measFrame(1,2) = yz;
measFrame(2,0) = zx;
measFrame(2,1) = zy;
measFrame(2,2) = zz;
measFrameTransp = measFrame.GetTranspose();
}
}
}
if (numComponents==6)
{
while (!it.IsAtEnd())
{
// T'=RTR'
VarPixType vec = it.Get();
FixPixType fixVec(vec.GetDataPointer());
if(readFrame)
{
TensorImage::PixelType tensor;
tensor.SetElement(0, vec.GetElement(0));
tensor.SetElement(1, vec.GetElement(1));
tensor.SetElement(2, vec.GetElement(2));
tensor.SetElement(3, vec.GetElement(3));
tensor.SetElement(4, vec.GetElement(4));
tensor.SetElement(5, vec.GetElement(5));
tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
fixVec = tensor;
}
ot.Set(fixVec);
++ot;
++it;
}
}
else if(numComponents==9)
{
while (!it.IsAtEnd())
{
VarPixType vec = it.Get();
TensorImage::PixelType tensor;
tensor.SetElement(0, vec.GetElement(0));
tensor.SetElement(1, vec.GetElement(1));
tensor.SetElement(2, vec.GetElement(2));
tensor.SetElement(3, vec.GetElement(4));
tensor.SetElement(4, vec.GetElement(5));
tensor.SetElement(5, vec.GetElement(8));
if(readFrame)
{
tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
}
FixPixType fixVec(tensor);
ot.Set(fixVec);
++ot;
++it;
}
}
else if (numComponents==1)
{
typedef itk::Image<float,4> ImageType;
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetImageIO(io);
reader->SetFileName(location);
reader->Update();
ImageType::Pointer img = reader->GetOutput();
itk::Size<4> size = img->GetLargestPossibleRegion().GetSize();
while (!ot.IsAtEnd())
{
TensorImage::PixelType tensor;
ImageType::IndexType idx;
idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2];
if (size[3]==6)
{
for (unsigned int te=0; te<size[3]; te++)
{
idx[3] = te;
tensor.SetElement(te, img->GetPixel(idx));
}
}
else if (size[3]==9)
{
idx[3] = 0;
tensor.SetElement(0, img->GetPixel(idx));
idx[3] = 1;
tensor.SetElement(1, img->GetPixel(idx));
idx[3] = 2;
tensor.SetElement(2, img->GetPixel(idx));
idx[3] = 4;
tensor.SetElement(3, img->GetPixel(idx));
idx[3] = 5;
tensor.SetElement(4, img->GetPixel(idx));
idx[3] = 8;
tensor.SetElement(5, img->GetPixel(idx));
}
else
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Unknown number of komponents for DTI file. Should be 6 or 9!");
if(readFrame)
{
tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
}
FixPixType fixVec(tensor);
ot.Set(fixVec);
++ot;
}
}
else
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Image has wrong number of pixel components!");
}
OutputType::Pointer resultImage = OutputType::New();
resultImage->InitializeByItk( vecImg.GetPointer() );
resultImage->SetVolume( vecImg->GetBufferPointer() );
result.push_back( resultImage.GetPointer() );
}
}
catch(std::exception& e)
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
}
catch(...)
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested DTI file!");
}
}
return result;
}
std::vector<itk::SmartPointer<BaseData> > NrrdQBallImageReader::Read()
{
std::vector<itk::SmartPointer<mitk::BaseData> > result;
std::string location = GetInputLocation();
if ( location == "")
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename of the vessel tree to be read is empty!");
}
else
{
try
{
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
typedef itk::VectorImage<float,3> ImageType;
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetImageIO(io);
reader->SetFileName(location);
reader->Update();
ImageType::Pointer img = reader->GetOutput();
typedef itk::Image<itk::Vector<float,QBALL_ODFSIZE>,3> VecImgType;
VecImgType::Pointer vecImg = VecImgType::New();
vecImg->SetSpacing( img->GetSpacing() ); // Set the image spacing
vecImg->SetOrigin( img->GetOrigin() ); // Set the image origin
vecImg->SetDirection( img->GetDirection() ); // Set the image direction
vecImg->SetLargestPossibleRegion( img->GetLargestPossibleRegion());
vecImg->SetBufferedRegion( img->GetLargestPossibleRegion() );
vecImg->Allocate();
itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
ot.GoToBegin();
itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
typedef ImageType::PixelType VarPixType;
typedef VecImgType::PixelType FixPixType;
for (it.GoToBegin(); !it.IsAtEnd(); ++it)
{
VarPixType vec = it.Get();
FixPixType fixVec(vec.GetDataPointer());
ot.Set(fixVec);
++ot;
}
OutputType::Pointer resultImage = OutputType::New();
resultImage->InitializeByItk( vecImg.GetPointer() );
resultImage->SetVolume( vecImg->GetBufferPointer() );
result.push_back( resultImage.GetPointer() );
try
{
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO << "Could not reset locale " << currLocale;
}
}
catch(std::exception& e)
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
}
catch(...)
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
}
}
return result;
}
void mitk::USLookupTableSource::GenerateData()
{
std::cout << "USLookupTableSource::generate data!" << std::endl;
OutputType::Pointer output = this->GetOutput();
output->SetVtkLookupTable( this->BuildVtkLookupTable( ) );
}
mitk::DataNodeSource::DataNodeSource()
{
// Create the output.
OutputType::Pointer output = static_cast<OutputType*> ( this->MakeOutput( 0 ).GetPointer() );
this->SetNthOutput(0, output.GetPointer());
}
void mitk::ImageLiveWireContourModelFilter::CreateDynamicCostMapByITK( const itk::Image<TPixel, VImageDimension>* 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<VImageDimension> > shortestPath;
mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
if(path == NULL)
{
OutputType::Pointer output = this->GetOutput();
mitk::ContourModel::VertexIterator it = output->IteratorBegin();
while( it != output->IteratorEnd() )
{
itk::Index<VImageDimension> 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<VImageDimension> 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<TPixel, VImageDimension>, itk::Image<TPixel, VImageDimension> > GradientMagnitudeFilterType;
typename GradientMagnitudeFilterType::Pointer gradientFilter = GradientMagnitudeFilterType::New();
gradientFilter->SetInput(inputImage);
gradientFilter->Update();
typename itk::Image<TPixel, VImageDimension>::Pointer gradientMagnImage = gradientFilter->GetOutput();
//get the path
//iterator of path
typename std::vector< itk::Index<VImageDimension> >::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<int>( 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);
}
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<OutputType*> ( this->MakeOutput( 0 ).GetPointer() );
this->SetNthOutput(0, output.GetPointer());
// OutputType::Pointer output = dynamic_cast<OutputType*> ( this->GetOutput() );
output->Expand(m_TimeStep+1);
// output->Clear();
mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
ShortestPathType::const_iterator pathIterator = shortestPath.begin();
while(pathIterator != shortestPath.end())
{
mitk::Point3D currentPoint;
currentPoint[0] = static_cast<mitk::ScalarType>( (*pathIterator)[0] );
currentPoint[1] = static_cast<mitk::ScalarType>( (*pathIterator)[1] );
currentPoint[2] = 0.0;
input->GetGeometry()->IndexToWorld(currentPoint, currentPoint);
output->AddVertex(currentPoint, false, m_TimeStep);
pathIterator++;
}
}
