diff --git a/Modules/IOExt/Internal/mitkUnstructuredGridVtkWriter.txx b/Modules/IOExt/Internal/mitkUnstructuredGridVtkWriter.txx
index 3f44c734b9..9e3d6f9376 100644
--- a/Modules/IOExt/Internal/mitkUnstructuredGridVtkWriter.txx
+++ b/Modules/IOExt/Internal/mitkUnstructuredGridVtkWriter.txx
@@ -1,196 +1,196 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef _MITK_UNSTRUCTURED_GRID_VTKWRITER_TXX_
#define _MITK_UNSTRUCTURED_GRID_VTKWRITER_TXX_
#include <itkLightObject.h>
#include <vtkLinearTransform.h>
#include <vtkTransformFilter.h>
#include <vtkUnstructuredGrid.h>
#include <vtkUnstructuredGridWriter.h>
#include <vtkXMLPUnstructuredGridWriter.h>
#include <vtkXMLUnstructuredGridWriter.h>
#include <sstream>
#include <cstdio>
#include <sys/stat.h>
#include <sys/types.h>
namespace mitk
{
template <class VTKWRITER>
UnstructuredGridVtkWriter<VTKWRITER>::UnstructuredGridVtkWriter() : m_Success(false)
{
this->SetNumberOfRequiredInputs(1);
}
template <class VTKWRITER>
UnstructuredGridVtkWriter<VTKWRITER>::~UnstructuredGridVtkWriter()
{
}
template <class VTKWRITER>
void UnstructuredGridVtkWriter<VTKWRITER>::GenerateData()
{
m_Success = false;
if (m_FileName == "")
{
itkWarningMacro(<< "Sorry, filename has not been set!");
return;
}
mitk::UnstructuredGrid::Pointer input = const_cast<mitk::UnstructuredGrid *>(this->GetInput());
if (input.IsNull())
{
itkWarningMacro(<< "Sorry, input to mitk::UnstructuredGridVtkWriter is NULL");
return;
}
VTKWRITER *unstructuredGridWriter = VTKWRITER::New();
vtkTransformFilter *transformPointSet = vtkTransformFilter::New();
vtkUnstructuredGrid *unstructuredGrid;
BaseGeometry *geometry;
if (input->GetTimeGeometry()->CountTimeSteps() > 1)
{
int t, timesteps;
timesteps = input->GetTimeGeometry()->CountTimeSteps();
for (t = 0; t < timesteps; ++t)
{
std::ostringstream filename;
geometry = input->GetGeometry(t);
if (input->GetTimeGeometry()->IsValidTimeStep(t))
{
- const mitk::TimeBounds &timebounds = input->GetTimeGeometry()->GetTimeBounds(t);
+ const mitk::TimeBounds timebounds = input->GetTimeGeometry()->GetTimeBounds(t);
filename << m_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E"
<< std::setprecision(0) << timebounds[1] << "_T" << t << GetDefaultExtension();
}
else
{
itkWarningMacro(<< "Error on write: TimeGeometry invalid of unstructured grid " << filename.str() << ".");
filename << m_FileName.c_str() << "_T" << t << GetDefaultExtension();
}
transformPointSet->SetInputData(input->GetVtkUnstructuredGrid(t));
transformPointSet->SetTransform(geometry->GetVtkTransform());
transformPointSet->UpdateWholeExtent();
unstructuredGrid = static_cast<vtkUnstructuredGrid *>(transformPointSet->GetOutput());
unstructuredGridWriter->SetFileName(filename.str().c_str());
unstructuredGridWriter->SetInputData(unstructuredGrid);
ExecuteWrite(unstructuredGridWriter);
}
}
else
{
geometry = input->GetGeometry();
transformPointSet->SetInputData(input->GetVtkUnstructuredGrid());
transformPointSet->SetTransform(geometry->GetVtkTransform());
transformPointSet->UpdateWholeExtent();
unstructuredGrid = static_cast<vtkUnstructuredGrid *>(transformPointSet->GetOutput());
unstructuredGridWriter->SetFileName(m_FileName.c_str());
unstructuredGridWriter->SetInputData(unstructuredGrid);
ExecuteWrite(unstructuredGridWriter);
}
transformPointSet->Delete();
unstructuredGridWriter->Delete();
m_Success = true;
}
template <class VTKWRITER>
void UnstructuredGridVtkWriter<VTKWRITER>::ExecuteWrite(VTKWRITER *vtkWriter)
{
struct stat fileStatus;
time_t timeBefore = 0;
if (!stat(vtkWriter->GetFileName(), &fileStatus))
{
timeBefore = fileStatus.st_mtime;
}
if (!vtkWriter->Write())
{
itkExceptionMacro(<< "Error during unstructured grid writing.");
}
// check if file can be written because vtkWriter doesn't check that
if (stat(vtkWriter->GetFileName(), &fileStatus) || (timeBefore == fileStatus.st_mtime))
{
itkExceptionMacro(<< "Error during unstructured grid writing: file could not be written");
}
}
template <class VTKWRITER>
void UnstructuredGridVtkWriter<VTKWRITER>::SetInput(BaseData *input)
{
this->ProcessObject::SetNthInput(0, input);
}
template <class VTKWRITER>
const UnstructuredGrid *UnstructuredGridVtkWriter<VTKWRITER>::GetInput()
{
if (this->GetNumberOfInputs() < 1)
{
return nullptr;
}
else
{
return dynamic_cast<UnstructuredGrid *>(this->ProcessObject::GetInput(0));
}
}
template <class VTKWRITER>
bool UnstructuredGridVtkWriter<VTKWRITER>::CanWriteBaseDataType(BaseData::Pointer data)
{
return (dynamic_cast<mitk::UnstructuredGrid *>(data.GetPointer()) != nullptr);
}
template <class VTKWRITER>
void UnstructuredGridVtkWriter<VTKWRITER>::DoWrite(BaseData::Pointer data)
{
if (CanWriteBaseDataType(data))
{
this->SetInput(dynamic_cast<mitk::UnstructuredGrid *>(data.GetPointer()));
this->Update();
}
}
template <class VTKWRITER>
std::vector<std::string> UnstructuredGridVtkWriter<VTKWRITER>::GetPossibleFileExtensions()
{
throw std::exception(); // no specialization available!
}
template <class VTKWRITER>
const char *UnstructuredGridVtkWriter<VTKWRITER>::GetDefaultFilename()
{
throw std::exception(); // no specialization available!
}
template <class VTKWRITER>
const char *UnstructuredGridVtkWriter<VTKWRITER>::GetFileDialogPattern()
{
throw std::exception(); // no specialization available!
}
template <class VTKWRITER>
const char *UnstructuredGridVtkWriter<VTKWRITER>::GetDefaultExtension()
{
throw std::exception(); // no specialization available!
}
}
#endif
diff --git a/Modules/LegacyIO/mitkImageWriter.cpp b/Modules/LegacyIO/mitkImageWriter.cpp
index 4cec0c6130..1b80e14b55 100644
--- a/Modules/LegacyIO/mitkImageWriter.cpp
+++ b/Modules/LegacyIO/mitkImageWriter.cpp
@@ -1,476 +1,476 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkImageWriter.h"
#include "mitkImage.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageReadAccessor.h"
#include "mitkImageTimeSelector.h"
#include "mitkItkPictureWrite.h"
#include <mitkLocaleSwitch.h>
#include <itkImageIOBase.h>
#include <itkImageIOFactory.h>
mitk::ImageWriter::ImageWriter() : m_UseCompression(true)
{
this->SetNumberOfRequiredInputs(1);
m_MimeType = "";
SetDefaultExtension();
}
mitk::ImageWriter::~ImageWriter()
{
}
void mitk::ImageWriter::SetFileName(const char *fileName)
{
if (fileName && (fileName == this->m_FileName))
{
return;
}
if (fileName)
{
this->m_FileName = fileName;
this->m_FileNameWithoutExtension = this->m_FileName;
this->m_Extension.clear();
std::size_t pos = this->m_FileName.find_last_of("/\\");
if (pos != std::string::npos)
{
std::size_t ppos = this->m_FileName.find_first_of('.', pos);
if (ppos != std::string::npos)
{
this->m_FileNameWithoutExtension = this->m_FileName.substr(0, ppos);
this->m_Extension = this->m_FileName.substr(ppos);
}
}
}
else
{
this->m_FileName.clear();
this->m_FileNameWithoutExtension.clear();
this->m_Extension.clear();
}
this->Modified();
}
void mitk::ImageWriter::SetFileName(const std::string &fileName)
{
this->SetFileName(fileName.c_str());
}
void mitk::ImageWriter::SetExtension(const char *extension)
{
if (extension && (extension == this->m_Extension))
{
return;
}
if (extension)
{
this->m_Extension = extension;
this->m_FileName = this->m_FileNameWithoutExtension + this->m_Extension;
}
else
{
this->m_Extension.clear();
this->m_FileName = this->m_FileNameWithoutExtension;
}
this->Modified();
}
void mitk::ImageWriter::SetExtension(const std::string &extension)
{
this->SetFileName(extension.c_str());
}
void mitk::ImageWriter::SetDefaultExtension()
{
this->m_Extension = ".mhd";
this->m_FileName = this->m_FileNameWithoutExtension + this->m_Extension;
this->Modified();
}
#include <vtkConfigure.h>
#include <vtkImageData.h>
#include <vtkXMLImageDataWriter.h>
static void writeVti(const char *filename, mitk::Image *image, int t = 0)
{
vtkXMLImageDataWriter *vtkwriter = vtkXMLImageDataWriter::New();
vtkwriter->SetFileName(filename);
vtkwriter->SetInputData(image->GetVtkImageData(t));
vtkwriter->Write();
vtkwriter->Delete();
}
#include <itkRGBAPixel.h>
void mitk::ImageWriter::WriteByITK(mitk::Image *image, const std::string &fileName)
{
MITK_INFO << "Writing image: " << fileName << std::endl;
// Pictures and picture series like .png are written via a different mechanism then volume images.
// So, they are still multiplexed and thus not support vector images.
if (fileName.find(".png") != std::string::npos || fileName.find(".tif") != std::string::npos ||
fileName.find(".jpg") != std::string::npos || fileName.find(".bmp") != std::string::npos)
{
try
{
// switch processing of single/multi-component images
if (image->GetPixelType(0).GetNumberOfComponents() == 1)
{
AccessByItk_1(image, _mitkItkPictureWrite, fileName);
}
else
{
AccessFixedPixelTypeByItk_1(image,
_mitkItkPictureWriteComposite,
MITK_ACCESSBYITK_PIXEL_TYPES_SEQ MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES_SEQ,
fileName);
}
}
catch (itk::ExceptionObject &e)
{
std::cerr << "Caught " << e.what() << std::endl;
}
catch (std::exception &e)
{
std::cerr << "Caught std::exception " << e.what() << std::endl;
}
return;
}
// Implementation of writer using itkImageIO directly. This skips the use
// of templated itkImageFileWriter, which saves the multiplexing on MITK side.
unsigned int dimension = image->GetDimension();
unsigned int *dimensions = image->GetDimensions();
mitk::PixelType pixelType = image->GetPixelType();
mitk::Vector3D mitkSpacing = image->GetGeometry()->GetSpacing();
mitk::Point3D mitkOrigin = image->GetGeometry()->GetOrigin();
// Due to templating in itk, we are forced to save a 4D spacing and 4D Origin, though they are not supported in MITK
itk::Vector<double, 4u> spacing4D;
spacing4D[0] = mitkSpacing[0];
spacing4D[1] = mitkSpacing[1];
spacing4D[2] = mitkSpacing[2];
spacing4D[3] = 1; // There is no support for a 4D spacing. However, we should have an valid value here
itk::Vector<double, 4u> origin4D;
origin4D[0] = mitkOrigin[0];
origin4D[1] = mitkOrigin[1];
origin4D[2] = mitkOrigin[2];
origin4D[3] = 0; // There is no support for a 4D origin. However, we should have an valid value here
itk::ImageIOBase::Pointer imageIO =
itk::ImageIOFactory::CreateImageIO(fileName.c_str(), itk::ImageIOFactory::WriteMode);
if (imageIO.IsNull())
{
itkExceptionMacro(<< "Error: Could not create itkImageIO via factory for file " << fileName);
}
// Set the necessary information for imageIO
imageIO->SetNumberOfDimensions(dimension);
imageIO->SetPixelType(pixelType.GetPixelType());
imageIO->SetComponentType(pixelType.GetComponentType() < PixelComponentUserType ?
static_cast<itk::ImageIOBase::IOComponentType>(pixelType.GetComponentType()) :
itk::ImageIOBase::UNKNOWNCOMPONENTTYPE);
imageIO->SetNumberOfComponents(pixelType.GetNumberOfComponents());
itk::ImageIORegion ioRegion(dimension);
for (unsigned int i = 0; i < dimension; i++)
{
imageIO->SetDimensions(i, dimensions[i]);
imageIO->SetSpacing(i, spacing4D[i]);
imageIO->SetOrigin(i, origin4D[i]);
mitk::Vector3D mitkDirection;
mitkDirection.SetVnlVector(
image->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
itk::Vector<double, 4u> direction4D;
direction4D[0] = mitkDirection[0];
direction4D[1] = mitkDirection[1];
direction4D[2] = mitkDirection[2];
// MITK only supports a 3x3 direction matrix. Due to templating in itk, however, we must
// save a 4x4 matrix for 4D images. in this case, add an homogneous component to the matrix.
if (i == 3)
direction4D[3] = 1; // homogenous component
else
direction4D[3] = 0;
vnl_vector<double> axisDirection(dimension);
for (unsigned int j = 0; j < dimension; j++)
{
axisDirection[j] = direction4D[j] / spacing4D[i];
}
imageIO->SetDirection(i, axisDirection);
ioRegion.SetSize(i, image->GetLargestPossibleRegion().GetSize(i));
ioRegion.SetIndex(i, image->GetLargestPossibleRegion().GetIndex(i));
}
// use compression if available
imageIO->SetUseCompression(m_UseCompression);
imageIO->SetIORegion(ioRegion);
imageIO->SetFileName(fileName);
ImageReadAccessor imageAccess(image);
imageIO->Write(imageAccess.GetData());
}
void mitk::ImageWriter::GenerateData()
{
mitk::LocaleSwitch localeSwitch("C");
if (m_FileName == "")
{
itkWarningMacro(<< "Sorry, filename has not been set!");
return;
}
FILE *tempFile = fopen(m_FileName.c_str(), "w");
if (tempFile == nullptr)
{
itkExceptionMacro(<< "File location not writeable");
return;
}
fclose(tempFile);
remove(m_FileName.c_str());
// Creating clone of input image, since i might change the geometry
mitk::Image::Pointer input = this->GetInput()->Clone();
// Check if geometry information will be lost
if (input->GetDimension() == 2)
{
if (!input->GetGeometry()->Is2DConvertable())
{
MITK_WARN << "Saving a 2D image with 3D geometry information. Geometry information will be lost! You might "
"consider using Convert2Dto3DImageFilter before saving.";
// set matrix to identity
mitk::AffineTransform3D::Pointer affTrans = mitk::AffineTransform3D::New();
affTrans->SetIdentity();
mitk::Vector3D spacing = input->GetGeometry()->GetSpacing();
mitk::Point3D origin = input->GetGeometry()->GetOrigin();
input->GetGeometry()->SetIndexToWorldTransform(affTrans);
input->GetGeometry()->SetSpacing(spacing);
input->GetGeometry()->SetOrigin(origin);
}
}
bool vti = (m_Extension.find(".vti") != std::string::npos);
// If the extension is NOT .pic and NOT .nrrd and NOT .nii and NOT .nii.gz the following block is entered
if (m_Extension.find(".pic") == std::string::npos && m_Extension.find(".nrrd") == std::string::npos &&
m_Extension.find(".nii") == std::string::npos && m_Extension.find(".nii.gz") == std::string::npos)
{
if (input->GetDimension() > 3)
{
int t, timesteps;
timesteps = input->GetDimension(3);
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput(input);
mitk::Image::Pointer image = timeSelector->GetOutput();
for (t = 0; t < timesteps; ++t)
{
std::ostringstream filename;
timeSelector->SetTimeNr(t);
timeSelector->Update();
if (input->GetTimeGeometry()->IsValidTimeStep(t))
{
- const mitk::TimeBounds &timebounds = input->GetTimeGeometry()->GetTimeBounds(t);
+ const mitk::TimeBounds timebounds = input->GetTimeGeometry()->GetTimeBounds(t);
filename << m_FileNameWithoutExtension << "_S" << std::setprecision(0) << timebounds[0] << "_E"
<< std::setprecision(0) << timebounds[1] << "_T" << t << m_Extension;
}
else
{
itkWarningMacro(<< "Error on write: TimeGeometry invalid of image " << filename.str() << ".");
filename << m_FileNameWithoutExtension << "_T" << t << m_Extension;
}
if (vti)
{
writeVti(filename.str().c_str(), input, t);
}
else
{
WriteByITK(image, filename.str());
}
}
}
else if (vti)
{
writeVti(m_FileName.c_str(), input);
}
else
{
WriteByITK(input, m_FileName);
}
}
else
{
// use the PicFileWriter for the .pic data type
if (m_Extension.find(".pic") != std::string::npos)
{
/* PicFileWriter::Pointer picWriter = PicFileWriter::New();
size_t found;
found = m_FileName.find( m_Extension ); // !!! HAS to be at the very end of the filename (not somewhere in the middle)
if( m_FileName.length() > 3 && found != m_FileName.length() - 4 )
{
//if Extension not in Filename
std::ostringstream filename;
filename << m_FileName.c_str() << m_Extension;
picWriter->SetFileName( filename.str().c_str() );
}
else
{
picWriter->SetFileName( m_FileName.c_str() );
}
picWriter->SetInputImage( input );
picWriter->Write();
*/ }
// use the ITK .nrrd Image writer
if (m_Extension.find(".nrrd") != std::string::npos || m_Extension.find(".nii") != std::string::npos ||
m_Extension.find(".nii.gz") != std::string::npos)
{
WriteByITK(input, this->m_FileName);
}
}
m_MimeType = "application/MITK.Pic";
}
bool mitk::ImageWriter::CanWriteDataType(DataNode *input)
{
if (input)
{
return this->CanWriteBaseDataType(input->GetData());
}
return false;
}
void mitk::ImageWriter::SetInput(DataNode *input)
{
if (input && CanWriteDataType(input))
this->ProcessObject::SetNthInput(0, dynamic_cast<mitk::Image *>(input->GetData()));
}
std::string mitk::ImageWriter::GetWritenMIMEType()
{
return m_MimeType;
}
std::vector<std::string> mitk::ImageWriter::GetPossibleFileExtensions()
{
std::vector<std::string> possibleFileExtensions;
possibleFileExtensions.push_back(".pic");
possibleFileExtensions.push_back(".pic.gz");
possibleFileExtensions.push_back(".bmp");
possibleFileExtensions.push_back(".dcm");
possibleFileExtensions.push_back(".DCM");
possibleFileExtensions.push_back(".dicom");
possibleFileExtensions.push_back(".DICOM");
possibleFileExtensions.push_back(".gipl");
possibleFileExtensions.push_back(".gipl.gz");
possibleFileExtensions.push_back(".mha");
possibleFileExtensions.push_back(".nii");
possibleFileExtensions.push_back(".nii.gz");
possibleFileExtensions.push_back(".nrrd");
possibleFileExtensions.push_back(".nhdr");
possibleFileExtensions.push_back(".png");
possibleFileExtensions.push_back(".PNG");
possibleFileExtensions.push_back(".spr");
possibleFileExtensions.push_back(".mhd");
possibleFileExtensions.push_back(".vtk");
possibleFileExtensions.push_back(".vti");
possibleFileExtensions.push_back(".hdr");
possibleFileExtensions.push_back(".img");
possibleFileExtensions.push_back(".img.gz");
possibleFileExtensions.push_back(".png");
possibleFileExtensions.push_back(".tif");
possibleFileExtensions.push_back(".jpg");
return possibleFileExtensions;
}
std::string mitk::ImageWriter::GetSupportedBaseData() const
{
return Image::GetStaticNameOfClass();
}
std::string mitk::ImageWriter::GetFileExtension()
{
return m_Extension;
}
void mitk::ImageWriter::SetInput(mitk::Image *image)
{
this->ProcessObject::SetNthInput(0, image);
}
const mitk::Image *mitk::ImageWriter::GetInput()
{
if (this->GetNumberOfInputs() < 1)
{
return nullptr;
}
else
{
return static_cast<const mitk::Image *>(this->ProcessObject::GetInput(0));
}
}
const char *mitk::ImageWriter::GetDefaultFilename()
{
return "Image.nrrd";
}
const char *mitk::ImageWriter::GetFileDialogPattern()
{
return "Nearly Raw Raster Data (*.nrrd);;"
"NIfTI format (*.nii *.nii.gz);;"
"VTK Image Data Files (*.vti);;"
"NRRD with detached header (*.nhdr);;"
"Analyze Format (*.hdr);;"
"MetaImage (*.mhd);;"
"Sets of 2D slices (*.png *.tiff *.jpg *.jpeg *.bmp);;"
"DICOM (*.dcm *.DCM *.dicom *.DICOM);;"
"UMDS GIPL Format Files (*.gipl *.gipl.gz)";
}
const char *mitk::ImageWriter::GetDefaultExtension()
{
return ".nrrd";
}
bool mitk::ImageWriter::CanWriteBaseDataType(BaseData::Pointer data)
{
return dynamic_cast<mitk::Image *>(data.GetPointer());
}
void mitk::ImageWriter::DoWrite(BaseData::Pointer data)
{
if (this->CanWriteBaseDataType(data))
{
this->SetInput(dynamic_cast<mitk::Image *>(data.GetPointer()));
this->Update();
}
}
void mitk::ImageWriter::SetUseCompression(bool useCompression)
{
m_UseCompression = useCompression;
}
diff --git a/Modules/LegacyIO/mitkSurfaceVtkWriter.txx b/Modules/LegacyIO/mitkSurfaceVtkWriter.txx
index 82b0c18fab..3072e4634c 100644
--- a/Modules/LegacyIO/mitkSurfaceVtkWriter.txx
+++ b/Modules/LegacyIO/mitkSurfaceVtkWriter.txx
@@ -1,171 +1,171 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkSurfaceVtkWriter.h"
#include <vtkConfigure.h>
#include <vtkErrorCode.h>
#include <vtkLinearTransform.h>
#include <vtkPolyData.h>
#include <vtkTransformPolyDataFilter.h>
#include <sstream>
#include <cstdio>
#include <sys/stat.h>
#include <sys/types.h>
template <class VTKWRITER>
mitk::SurfaceVtkWriter<VTKWRITER>::SurfaceVtkWriter() : m_WriterWriteHasReturnValue(false)
{
this->SetNumberOfRequiredInputs(1);
m_VtkWriter = vtkSmartPointer<VtkWriterType>::New();
// enable to write ascii-formatted-file
// m_VtkWriter->SetFileTypeToASCII();
SetDefaultExtension(); // and information about the Writer's Write() method
}
template <class VTKWRITER>
mitk::SurfaceVtkWriter<VTKWRITER>::~SurfaceVtkWriter()
{
}
template <class VTKWRITER>
void mitk::SurfaceVtkWriter<VTKWRITER>::SetDefaultExtension()
{
m_Extension = ".vtk";
}
template <class VTKWRITER>
void mitk::SurfaceVtkWriter<VTKWRITER>::ExecuteWrite(VtkWriterType *vtkWriter)
{
if (vtkWriter->Write() == 0 || vtkWriter->GetErrorCode() != 0)
{
itkExceptionMacro(<< "Error during surface writing: "
<< vtkErrorCode::GetStringFromErrorCode(vtkWriter->GetErrorCode()));
}
}
template <class VTKWRITER>
void mitk::SurfaceVtkWriter<VTKWRITER>::GenerateData()
{
if (m_FileName == "")
{
itkWarningMacro(<< "Sorry, filename has not been set!");
return;
}
mitk::Surface::Pointer input = const_cast<mitk::Surface *>(this->GetInput());
vtkSmartPointer<vtkTransformPolyDataFilter> transformPolyData = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
vtkPolyData *polyData;
BaseGeometry *geometry;
unsigned int t, timesteps = input->GetTimeGeometry()->CountTimeSteps();
for (t = 0; t < timesteps; ++t)
{
// surfaces do not have to exist in all timeteps; therefor, only write valid surfaces
if (input->GetVtkPolyData(t) == nullptr)
continue;
std::ostringstream filename;
filename.imbue(::std::locale::classic());
geometry = input->GetGeometry(t);
if (timesteps > 1)
{
if (input->GetTimeGeometry()->IsValidTimeStep(t))
{
- const TimeBounds &timebounds = input->GetTimeGeometry()->GetTimeBounds(t);
+ const TimeBounds timebounds = input->GetTimeGeometry()->GetTimeBounds(t);
filename << m_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0)
<< timebounds[1] << "_T" << t << m_Extension;
}
else
{
itkWarningMacro(<< "Error on write: TimeGeometry invalid of surface " << filename.str() << ".");
filename << m_FileName.c_str() << "_T" << t << m_Extension;
}
m_VtkWriter->SetFileName(filename.str().c_str());
}
else
m_VtkWriter->SetFileName(m_FileName.c_str());
transformPolyData->SetInputData(input->GetVtkPolyData(t));
transformPolyData->SetTransform(geometry->GetVtkTransform());
transformPolyData->UpdateWholeExtent();
polyData = transformPolyData->GetOutput();
m_VtkWriter->SetInputData(polyData);
ExecuteWrite(m_VtkWriter);
}
m_MimeType = "application/MITK.Surface";
}
template <class VTKWRITER>
void mitk::SurfaceVtkWriter<VTKWRITER>::SetInput(mitk::Surface *surface)
{
this->ProcessObject::SetNthInput(0, surface);
}
template <class VTKWRITER>
const mitk::Surface *mitk::SurfaceVtkWriter<VTKWRITER>::GetInput()
{
if (this->GetNumberOfInputs() < 1)
{
return nullptr;
}
else
{
return static_cast<const Surface *>(this->ProcessObject::GetInput(0));
}
}
template <class VTKWRITER>
bool mitk::SurfaceVtkWriter<VTKWRITER>::CanWriteDataType(DataNode *input)
{
if (input)
{
BaseData *data = input->GetData();
if (data)
{
Surface::Pointer surface = dynamic_cast<Surface *>(data);
if (surface.IsNotNull())
{
SetDefaultExtension();
return true;
}
}
}
return false;
}
template <class VTKWRITER>
void mitk::SurfaceVtkWriter<VTKWRITER>::SetInput(DataNode *input)
{
if (input && CanWriteDataType(input))
SetInput(dynamic_cast<Surface *>(input->GetData()));
}
template <class VTKWRITER>
std::string mitk::SurfaceVtkWriter<VTKWRITER>::GetWritenMIMEType()
{
return m_MimeType;
}
template <class VTKWRITER>
std::string mitk::SurfaceVtkWriter<VTKWRITER>::GetFileExtension()
{
return m_Extension;
}
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
index faa81aca74..5870887320 100644
--- a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
@@ -1,628 +1,620 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkContourModelUtils.h>
#include <mitkLiveWireTool2D.h>
#include <mitkLiveWireTool2D.xpm>
#include <mitkToolManager.h>
#include <usGetModuleContext.h>
#include <usModuleResource.h>
#include <type_traits>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, LiveWireTool2D, "LiveWire tool");
}
mitk::LiveWireTool2D::LiveWireTool2D()
: SegTool2D("LiveWireTool"), m_CreateAndUseDynamicCosts(false)
{
}
mitk::LiveWireTool2D::~LiveWireTool2D()
{
this->ClearSegmentation();
}
void mitk::LiveWireTool2D::RemoveHelperObjects()
{
auto dataStorage = m_ToolManager->GetDataStorage();
if (nullptr == dataStorage)
return;
for (const auto &editingContour : m_EditingContours)
dataStorage->Remove(editingContour.first);
for (const auto &workingContour : m_WorkingContours)
dataStorage->Remove(workingContour.first);
if (m_EditingContourNode.IsNotNull())
dataStorage->Remove(m_EditingContourNode);
if (m_LiveWireContourNode.IsNotNull())
dataStorage->Remove(m_LiveWireContourNode);
if (m_ContourNode.IsNotNull())
dataStorage->Remove(m_ContourNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::LiveWireTool2D::ReleaseHelperObjects()
{
this->RemoveHelperObjects();
m_EditingContours.clear();
m_WorkingContours.clear();
m_EditingContourNode = nullptr;
m_EditingContour = nullptr;
m_LiveWireContourNode = nullptr;
m_LiveWireContour = nullptr;
m_ContourNode = nullptr;
m_Contour = nullptr;
}
void mitk::LiveWireTool2D::ReleaseInteractors()
{
this->EnableContourLiveWireInteraction(false);
m_LiveWireInteractors.clear();
}
void mitk::LiveWireTool2D::ConnectActionsAndFunctions()
{
CONNECT_CONDITION("CheckContourClosed", OnCheckPoint);
CONNECT_FUNCTION("InitObject", OnInitLiveWire);
CONNECT_FUNCTION("AddPoint", OnAddPoint);
CONNECT_FUNCTION("CtrlAddPoint", OnAddPoint);
CONNECT_FUNCTION("MovePoint", OnMouseMoveNoDynamicCosts);
CONNECT_FUNCTION("FinishContour", OnFinish);
CONNECT_FUNCTION("DeletePoint", OnLastSegmentDelete);
CONNECT_FUNCTION("CtrlMovePoint", OnMouseMoved);
}
const char **mitk::LiveWireTool2D::GetXPM() const
{
return mitkLiveWireTool2D_xpm;
}
us::ModuleResource mitk::LiveWireTool2D::GetIconResource() const
{
return us::GetModuleContext()->GetModule()->GetResource("LiveWire_48x48.png");
}
us::ModuleResource mitk::LiveWireTool2D::GetCursorIconResource() const
{
return us::GetModuleContext()->GetModule()->GetResource("LiveWire_Cursor_32x32.png");
}
const char *mitk::LiveWireTool2D::GetName() const
{
return "Live Wire";
}
void mitk::LiveWireTool2D::Activated()
{
Superclass::Activated();
this->ResetToStartState();
this->EnableContourLiveWireInteraction(true);
}
void mitk::LiveWireTool2D::Deactivated()
{
this->ConfirmSegmentation();
Superclass::Deactivated();
}
void mitk::LiveWireTool2D::UpdateLiveWireContour()
{
if (m_Contour.IsNotNull())
{
auto timeGeometry = m_Contour->GetTimeGeometry()->Clone();
m_LiveWireContour = this->m_LiveWireFilter->GetOutput();
m_LiveWireContour->SetTimeGeometry(timeGeometry); //needed because the results of the filter are always from 0 ms to 1 ms and the filter also resets its outputs.
m_LiveWireContourNode->SetData(this->m_LiveWireContour);
}
}
void mitk::LiveWireTool2D::OnTimePointChanged()
{
auto reference = this->GetReferenceData();
if (nullptr == reference || m_PlaneGeometry.IsNull() || m_LiveWireFilter.IsNull() || m_LiveWireContourNode.IsNull())
return;
auto timeStep = reference->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
m_ReferenceDataSlice = GetAffectedImageSliceAs2DImageByTimePoint(m_PlaneGeometry, reference, timeStep);
m_LiveWireFilter->SetInput(m_ReferenceDataSlice);
m_LiveWireFilter->Update();
this->UpdateLiveWireContour();
RenderingManager::GetInstance()->RequestUpdateAll();
};
void mitk::LiveWireTool2D::EnableContourLiveWireInteraction(bool on)
{
for (const auto &interactor : m_LiveWireInteractors)
interactor->EnableInteraction(on);
}
void mitk::LiveWireTool2D::ConfirmSegmentation()
{
auto referenceImage = this->GetReferenceData();
auto workingImage = this->GetWorkingData();
if (nullptr != referenceImage && nullptr != workingImage)
{
std::vector<SliceInformation> sliceInfos;
sliceInfos.reserve(m_WorkingContours.size());
const auto currentTimePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
TimeStepType workingImageTimeStep = workingImage->GetTimeGeometry()->TimePointToTimeStep(currentTimePoint);
for (const auto &workingContour : m_WorkingContours)
{
auto contour = dynamic_cast<ContourModel *>(workingContour.first->GetData());
if (nullptr == contour || contour->IsEmpty())
continue;
auto sameSlicePredicate = [&workingContour, workingImageTimeStep](const SliceInformation& si) { return workingContour.second->IsOnPlane(si.plane) && workingImageTimeStep == si.timestep; };
auto finding = std::find_if(sliceInfos.begin(), sliceInfos.end(), sameSlicePredicate);
if (finding == sliceInfos.end())
{
auto workingSlice = this->GetAffectedImageSliceAs2DImage(workingContour.second, workingImage, workingImageTimeStep)->Clone();
sliceInfos.emplace_back(workingSlice, workingContour.second, workingImageTimeStep);
finding = std::prev(sliceInfos.end());
}
//cast const away is OK in this case, because these are all slices created and manipulated
//localy in this function call. And we want to keep the high constness of SliceInformation for
//public interfaces.
auto workingSlice = const_cast<Image*>(finding->slice.GetPointer());
auto projectedContour = ContourModelUtils::ProjectContourTo2DSlice(workingSlice, contour, true, false);
int activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
ContourModelUtils::FillContourInSlice(
projectedContour, workingSlice, workingImage, activePixelValue);
}
this->WriteBackSegmentationResults(sliceInfos);
}
this->ClearSegmentation();
}
void mitk::LiveWireTool2D::ClearSegmentation()
{
this->ReleaseHelperObjects();
this->ReleaseInteractors();
this->ResetToStartState();
}
bool mitk::LiveWireTool2D::IsPositionEventInsideImageRegion(mitk::InteractionPositionEvent *positionEvent,
mitk::BaseData *data)
{
bool isPositionEventInsideImageRegion = nullptr != data && data->GetGeometry()->IsInside(positionEvent->GetPositionInWorld());
if (!isPositionEventInsideImageRegion)
MITK_WARN("LiveWireTool2D") << "PositionEvent is outside ImageRegion!";
return isPositionEventInsideImageRegion;
}
mitk::ContourModel::Pointer mitk::LiveWireTool2D::CreateNewContour() const
{
auto workingData = this->GetWorkingData();
if (nullptr == workingData)
{
this->InteractiveSegmentationBugMessage("Cannot create new contour. No valid working data is set. Application is in invalid state.");
mitkThrow() << "Cannot create new contour. No valid working data is set. Application is in invalid state.";
}
- const auto minTime = workingData->GetTimeGeometry()->GetMinimumTimePoint();
- auto duration = workingData->GetTimeGeometry()->GetMaximumTimePoint() - minTime;
-
- if (duration <= 0)
- {
- duration = 1.;
- };
-
auto contour = ContourModel::New();
//generate a time geometry that is always visible as the working contour should always be.
auto contourTimeGeometry = ProportionalTimeGeometry::New();
contourTimeGeometry->SetStepDuration(std::numeric_limits<TimePointType>::max());
contourTimeGeometry->SetTimeStepGeometry(contour->GetTimeGeometry()->GetGeometryForTimeStep(0)->Clone(), 0);
contour->SetTimeGeometry(contourTimeGeometry);
return contour;
}
void mitk::LiveWireTool2D::OnInitLiveWire(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (nullptr == positionEvent)
return;
auto workingDataNode = this->GetWorkingDataNode();
if (!IsPositionEventInsideImageRegion(positionEvent, workingDataNode->GetData()))
{
this->ResetToStartState();
return;
}
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
m_Contour = this->CreateNewContour();
m_ContourNode = mitk::DataNode::New();
m_ContourNode->SetData(m_Contour);
m_ContourNode->SetName("working contour node");
m_ContourNode->SetProperty("layer", IntProperty::New(100));
m_ContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
m_ContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_ContourNode->AddProperty("contour.color", ColorProperty::New(1.0f, 1.0f, 0.0f), nullptr, true);
m_ContourNode->AddProperty("contour.points.color", ColorProperty::New(1.0f, 0.0f, 0.1f), nullptr, true);
m_ContourNode->AddProperty("contour.controlpoints.show", BoolProperty::New(true), nullptr, true);
m_LiveWireContour = this->CreateNewContour();
m_LiveWireContourNode = mitk::DataNode::New();
m_LiveWireContourNode->SetData(m_LiveWireContour);
m_LiveWireContourNode->SetName("active livewire node");
m_LiveWireContourNode->SetProperty("layer", IntProperty::New(101));
m_LiveWireContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
m_LiveWireContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_LiveWireContourNode->AddProperty("contour.color", ColorProperty::New(0.1f, 1.0f, 0.1f), nullptr, true);
m_LiveWireContourNode->AddProperty("contour.width", mitk::FloatProperty::New(4.0f), nullptr, true);
m_EditingContour = this->CreateNewContour();
m_EditingContourNode = mitk::DataNode::New();
m_EditingContourNode->SetData(m_EditingContour);
m_EditingContourNode->SetName("editing node");
m_EditingContourNode->SetProperty("layer", IntProperty::New(102));
m_EditingContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
m_EditingContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_EditingContourNode->AddProperty("contour.color", ColorProperty::New(0.1f, 1.0f, 0.1f), nullptr, true);
m_EditingContourNode->AddProperty("contour.points.color", ColorProperty::New(0.0f, 0.0f, 1.0f), nullptr, true);
m_EditingContourNode->AddProperty("contour.width", mitk::FloatProperty::New(4.0f), nullptr, true);
auto dataStorage = m_ToolManager->GetDataStorage();
dataStorage->Add(m_ContourNode, workingDataNode);
dataStorage->Add(m_LiveWireContourNode, workingDataNode);
dataStorage->Add(m_EditingContourNode, workingDataNode);
// Set current slice as input for ImageToLiveWireContourFilter
m_ReferenceDataSlice = this->GetAffectedReferenceSlice(positionEvent);
auto origin = m_ReferenceDataSlice->GetSlicedGeometry()->GetOrigin();
m_ReferenceDataSlice->GetSlicedGeometry()->WorldToIndex(origin, origin);
m_ReferenceDataSlice->GetSlicedGeometry()->IndexToWorld(origin, origin);
m_ReferenceDataSlice->GetSlicedGeometry()->SetOrigin(origin);
m_LiveWireFilter = ImageLiveWireContourModelFilter::New();
m_LiveWireFilter->SetInput(m_ReferenceDataSlice);
// Map click to pixel coordinates
auto click = positionEvent->GetPositionInWorld();
itk::Index<3> idx;
m_ReferenceDataSlice->GetGeometry()->WorldToIndex(click, idx);
// Get the pixel with the highest gradient in a 7x7 region
itk::Index<3> indexWithHighestGradient;
AccessFixedDimensionByItk_2(m_ReferenceDataSlice, FindHighestGradientMagnitudeByITK, 2, idx, indexWithHighestGradient);
click[0] = indexWithHighestGradient[0];
click[1] = indexWithHighestGradient[1];
click[2] = indexWithHighestGradient[2];
m_ReferenceDataSlice->GetGeometry()->IndexToWorld(click, click);
// Set initial start point
m_Contour->AddVertex(click, true);
m_LiveWireFilter->SetStartPoint(click);
// Remember PlaneGeometry to determine if events were triggered in the same plane
m_PlaneGeometry = interactionEvent->GetSender()->GetCurrentWorldPlaneGeometry();
m_CreateAndUseDynamicCosts = true;
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::LiveWireTool2D::OnAddPoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
// Complete LiveWire interaction for the last segment. Add current LiveWire contour to
// the finished contour and reset to start a new segment and computation.
auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (nullptr == positionEvent)
return;
if (m_PlaneGeometry.IsNotNull())
{
// Check if the point is in the correct slice
if (m_PlaneGeometry->DistanceFromPlane(positionEvent->GetPositionInWorld()) > mitk::sqrteps)
return;
}
// Add repulsive points to avoid getting the same path again
std::for_each(m_LiveWireContour->IteratorBegin(), m_LiveWireContour->IteratorEnd(), [this](ContourElement::VertexType *vertex) {
ImageLiveWireContourModelFilter::InternalImageType::IndexType idx;
this->m_ReferenceDataSlice->GetGeometry()->WorldToIndex(vertex->Coordinates, idx);
this->m_LiveWireFilter->AddRepulsivePoint(idx);
});
// Remove duplicate first vertex, it's already contained in m_Contour
m_LiveWireContour->RemoveVertexAt(0);
// Set last point as control point
m_LiveWireContour->SetControlVertexAt(m_LiveWireContour->GetNumberOfVertices() - 1);
// Merge contours
m_Contour->Concatenate(m_LiveWireContour);
// Clear the LiveWire contour and reset the corresponding DataNode
m_LiveWireContour->Clear();
// Set new start point
m_LiveWireFilter->SetStartPoint(positionEvent->GetPositionInWorld());
if (m_CreateAndUseDynamicCosts)
{
// Use dynamic cost map for next update
m_LiveWireFilter->CreateDynamicCostMap(m_Contour);
m_LiveWireFilter->SetUseDynamicCostMap(true);
}
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::LiveWireTool2D::OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent)
{
// Compute LiveWire segment from last control point to current mouse position
auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (nullptr == positionEvent)
return;
m_LiveWireFilter->SetEndPoint(positionEvent->GetPositionInWorld());
m_LiveWireFilter->Update();
this->UpdateLiveWireContour();
RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::LiveWireTool2D::OnMouseMoveNoDynamicCosts(StateMachineAction *, InteractionEvent *interactionEvent)
{
m_LiveWireFilter->SetUseDynamicCostMap(false);
this->OnMouseMoved(nullptr, interactionEvent);
m_LiveWireFilter->SetUseDynamicCostMap(true);
}
bool mitk::LiveWireTool2D::OnCheckPoint(const InteractionEvent *interactionEvent)
{
// Check double click on first control point to finish the LiveWire tool
auto positionEvent = dynamic_cast<const mitk::InteractionPositionEvent *>(interactionEvent);
if (nullptr == positionEvent)
return false;
mitk::Point3D click = positionEvent->GetPositionInWorld();
mitk::Point3D first = this->m_Contour->GetVertexAt(0)->Coordinates;
return first.EuclideanDistanceTo(click) < 4.5;
}
void mitk::LiveWireTool2D::OnFinish(StateMachineAction *, InteractionEvent *interactionEvent)
{
// Finish LiveWire tool interaction
auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (nullptr == positionEvent)
return;
// Remove last control point added by double click
m_Contour->RemoveVertexAt(m_Contour->GetNumberOfVertices() - 1);
// Save contour and corresponding plane geometry to list
this->m_WorkingContours.emplace_back(std::make_pair(m_ContourNode, positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()->Clone()));
this->m_EditingContours.emplace_back(std::make_pair(m_EditingContourNode, positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()->Clone()));
m_LiveWireFilter->SetUseDynamicCostMap(false);
this->FinishTool();
}
void mitk::LiveWireTool2D::FinishTool()
{
auto numberOfTimesteps = static_cast<int>(m_Contour->GetTimeSteps());
for (int i = 0; i <= numberOfTimesteps; ++i)
m_Contour->Close(i);
m_ToolManager->GetDataStorage()->Remove(m_LiveWireContourNode);
m_LiveWireContourNode = nullptr;
m_LiveWireContour = nullptr;
m_ContourInteractor = mitk::ContourModelLiveWireInteractor::New();
m_ContourInteractor->SetDataNode(m_ContourNode);
m_ContourInteractor->LoadStateMachine("ContourModelModificationInteractor.xml", us::GetModuleContext()->GetModule());
m_ContourInteractor->SetEventConfig("ContourModelModificationConfig.xml", us::GetModuleContext()->GetModule());
m_ContourInteractor->SetWorkingImage(this->m_ReferenceDataSlice);
m_ContourInteractor->SetEditingContourModelNode(this->m_EditingContourNode);
m_ContourNode->SetDataInteractor(m_ContourInteractor.GetPointer());
this->m_LiveWireInteractors.push_back(m_ContourInteractor);
}
void mitk::LiveWireTool2D::OnLastSegmentDelete(StateMachineAction *, InteractionEvent *interactionEvent)
{
// If last point of current contour will be removed go to start state and remove nodes
if (m_Contour->GetNumberOfVertices() <= 1)
{
auto dataStorage = m_ToolManager->GetDataStorage();
dataStorage->Remove(m_LiveWireContourNode);
dataStorage->Remove(m_ContourNode);
dataStorage->Remove(m_EditingContourNode);
m_LiveWireContour = this->CreateNewContour();
m_LiveWireContourNode->SetData(m_LiveWireContour);
m_Contour = this->CreateNewContour();
m_ContourNode->SetData(m_Contour);
this->ResetToStartState();
}
else // Remove last segment from contour and reset LiveWire contour
{
m_LiveWireContour = this->CreateNewContour();
m_LiveWireContourNode->SetData(m_LiveWireContour);
auto newContour = this->CreateNewContour();
auto begin = m_Contour->IteratorBegin();
// Iterate from last point to next active point
auto 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);
auto it = m_Contour->IteratorBegin();
// Fll new Contour
while (it <= newLast)
{
newContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint);
++it;
}
newContour->SetClosed(m_Contour->IsClosed());
m_ContourNode->SetData(newContour);
m_Contour = newContour;
mitk::RenderingManager::GetInstance()->RequestUpdate(interactionEvent->GetSender()->GetRenderWindow());
}
}
template <typename TPixel, unsigned int VImageDimension>
void mitk::LiveWireTool2D::FindHighestGradientMagnitudeByITK(itk::Image<TPixel, VImageDimension> *inputImage,
itk::Index<3> &index,
itk::Index<3> &returnIndex)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef typename InputImageType::IndexType IndexType;
const auto MAX_X = inputImage->GetLargestPossibleRegion().GetSize()[0];
const auto MAX_Y = 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 (MAX_X - index[0] < 7)
startRegion[0] = MAX_X - 7;
if (MAX_Y - index[1] < 7)
startRegion[1] = MAX_Y - 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 gradientMagnitudeImage;
gradientMagnitudeImage = 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 = gradientMagnitudeImage->GetPixel(currentIndex);
// Check for new max
if (maxGradientMagnitude < gradientMagnitude)
{
maxGradientMagnitude = gradientMagnitude;
returnIndex[0] = currentIndex[0];
returnIndex[1] = currentIndex[1];
returnIndex[2] = 0.0;
}
}
currentIndex[1] = index[1];
}
}