developer_doc/16.5.0-fx-rc9/cx_dilation_filter_8cpp_source.html

 /*=========================================================================

 This file is part of CustusX, an Image Guided Therapy Application.


 Copyright (c) 2008-2014, SINTEF Department of Medical Technology

 All rights reserved.


 Redistribution and use in source and binary forms, with or without

 modification, are permitted provided that the following conditions are met:


 1. Redistributions of source code must retain the above copyright notice,

    this list of conditions and the following disclaimer.


 2. Redistributions in binary form must reproduce the above copyright notice,

    this list of conditions and the following disclaimer in the documentation

    and/or other materials provided with the distribution.


 3. Neither the name of the copyright holder nor the names of its contributors

    may be used to endorse or promote products derived from this software

    without specific prior written permission.


 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 =========================================================================*/


 #include "cxDilationFilter.h"


 #include "cxDoubleProperty.h"

 #include "cxColorProperty.h"

 #include "cxBoolProperty.h"

 #include "cxStringProperty.h"

 #include "cxSelectDataStringProperty.h"


 #include <itkBinaryDilateImageFilter.h>

 #include <itkBinaryBallStructuringElement.h>

 #include "cxAlgorithmHelpers.h"

 #include <vtkImageCast.h>

 #include "cxUtilHelpers.h"

 #include "cxContourFilter.h"

 #include "cxMesh.h"

 #include "cxImage.h"

 #include "cxPatientModelService.h"

 #include "cxVolumeHelpers.h"

 #include "cxVisServices.h"


 namespace cx {


 DilationFilter::DilationFilter(VisServicesPtr services) :

         FilterImpl(services)

 {

 }


 QString DilationFilter::getName() const

 {

         return "Dilation";

 }


 QString DilationFilter::getType() const

 {

         return "DilationFilter";

 }


 QString DilationFilter::getHelp() const

 {

         return "<html>"

                 "<h3>Dilation Filter.</h3>"

                 "<p>This filter dilates a binary volume with a given radius in mm.<p>"

                 "<p>The dilation is performed using a ball structuring element<p>"

                 "</html>";

 }


 DoublePropertyPtr DilationFilter::getDilationRadiusOption(QDomElement root)

 {

         DoublePropertyPtr retval = DoubleProperty::initialize("Dilation radius (mm)", "",

     "Set dilation radius in mm", 1, DoubleRange(1, 20, 1), 0,

                     root);

         retval->setGuiRepresentation(DoublePropertyBase::grSLIDER);

         return retval;

 }


 BoolPropertyPtr DilationFilter::getGenerateSurfaceOption(QDomElement root)

 {

         BoolPropertyPtr retval = BoolProperty::initialize("Generate Surface", "",

                                                                                 "Generate a surface of the output volume", true,

                                                                                     root);

         return retval;

 }


 ColorPropertyPtr DilationFilter::getColorOption(QDomElement root)

 {

         return ColorProperty::initialize("Color", "",

                                                     "Color of output model.",

                                                     QColor("green"), root);

 }


 void DilationFilter::createOptions()

 {

         mOptionsAdapters.push_back(this->getDilationRadiusOption(mOptions));

         mOptionsAdapters.push_back(this->getGenerateSurfaceOption(mOptions));

         mOptionsAdapters.push_back(this->getColorOption(mOptions));

 }


 void DilationFilter::createInputTypes()

 {

         SelectDataStringPropertyBasePtr temp;


         temp = StringPropertySelectImage::New(mServices->patient());

         temp->setValueName("Input");

         temp->setHelp("Select segmentation input for dilation");

         mInputTypes.push_back(temp);

 }


 void DilationFilter::createOutputTypes()

 {

         SelectDataStringPropertyBasePtr temp;


         temp = StringPropertySelectData::New(mServices->patient());

         temp->setValueName("Output");

         temp->setHelp("Dilated segmentation image");

         mOutputTypes.push_back(temp);


         temp = StringPropertySelectData::New(mServices->patient());

         temp->setValueName("Contour");

         temp->setHelp("Output contour generated from dilated segmentation image.");

         mOutputTypes.push_back(temp);

 }


 bool DilationFilter::preProcess() {


     return FilterImpl::preProcess();

 }


 bool DilationFilter::execute() {

         ImagePtr input = this->getCopiedInputImage();

         if (!input)

                 return false;


         double radius = this->getDilationRadiusOption(mCopiedOptions)->getValue();


         // Convert radius in mm to radius in voxels for the structuring element

         Eigen::Array3d spacing = input->getSpacing();

         itk::Size<3> radiusInVoxels;

         radiusInVoxels[0] = radius/spacing(0);

         radiusInVoxels[1] = radius/spacing(1);

         radiusInVoxels[2] = radius/spacing(2);


         itkImageType::ConstPointer itkImage = AlgorithmHelper::getITKfromSSCImage(input);


         // Create structuring element

         typedef itk::BinaryBallStructuringElement<unsigned char,3> StructuringElementType;

     StructuringElementType structuringElement;

     structuringElement.SetRadius(radiusInVoxels);

     structuringElement.CreateStructuringElement();


         // Dilation

         typedef itk::BinaryDilateImageFilter<itkImageType, itkImageType, StructuringElementType> dilateFilterType;

         dilateFilterType::Pointer dilationFilter = dilateFilterType::New();

         dilationFilter->SetInput(itkImage);

         dilationFilter->SetKernel(structuringElement);

         dilationFilter->SetDilateValue(1);

         dilationFilter->Update();

         itkImage = dilationFilter->GetOutput();


         //Convert ITK to VTK

         itkToVtkFilterType::Pointer itkToVtkFilter = itkToVtkFilterType::New();

         itkToVtkFilter->SetInput(itkImage);

         itkToVtkFilter->Update();


         vtkImageDataPtr rawResult = vtkImageDataPtr::New();

         rawResult->DeepCopy(itkToVtkFilter->GetOutput());


         vtkImageCastPtr imageCast = vtkImageCastPtr::New();

         imageCast->SetInputData(rawResult);

         imageCast->SetOutputScalarTypeToUnsignedChar();

         imageCast->Update();

         rawResult = imageCast->GetOutput();


         // TODO: possible memory problem here - check debug mem system of itk/vtk


         mRawResult =  rawResult;


         BoolPropertyPtr generateSurface = this->getGenerateSurfaceOption(mCopiedOptions);

         if (generateSurface->getValue())

         {

         double threshold = 1;

         mRawContour = ContourFilter::execute(mRawResult, threshold);

         }


     return true;

 }


 bool DilationFilter::postProcess()

 {

         if (!mRawResult)

                 return false;


         ImagePtr input = this->getCopiedInputImage();


         if (!input)

                 return false;


         QString uid = input->getUid() + "_seg%1";

         QString name = input->getName()+" seg%1";

         ImagePtr output = createDerivedImage(mServices->patient(),

                                                                                  uid, name,

                                                                                  mRawResult, input);

         mRawResult = NULL;

         if (!output)

                 return false;


         output->resetTransferFunctions();

         mServices->patient()->insertData(output);


         // set output

         mOutputTypes.front()->setValue(output->getUid());


         // set contour output

         if (mRawContour!=NULL)

         {

                 ColorPropertyPtr colorOption = this->getColorOption(mOptions);

                 MeshPtr contour = ContourFilter::postProcess(mServices->patient(), mRawContour, output, colorOption->getValue());

                 mOutputTypes[1]->setValue(contour->getUid());

                 mRawContour = vtkPolyDataPtr();

         }


     return true;

 }


 } // namespace cx

cxDoubleProperty.h

cxStringProperty.h

cx::DilationFilter::preProcess
bool preProcess()
Definition: cxDilationFilter.cpp:137

cx::DilationFilter::DilationFilter
DilationFilter(VisServicesPtr services)
Definition: cxDilationFilter.cpp:56

cx::BoolProperty::initialize
static BoolPropertyPtr initialize(const QString &uid, QString name, QString help, bool value, QDomNode root=QDomNode())
Definition: cxBoolProperty.cpp:51

cxDilationFilter.h

cx::FilterImpl::mInputTypes
std::vector< SelectDataStringPropertyBasePtr > mInputTypes
Definition: cxFilterImpl.h:94

cx::FilterImpl::mCopiedOptions
QDomElement mCopiedOptions
Definition: cxFilterImpl.h:101

cx::DilationFilter::getName
virtual QString getName() const
Definition: cxDilationFilter.cpp:61

cx::DilationFilter::createOutputTypes
virtual void createOutputTypes()
Definition: cxDilationFilter.cpp:122

cx::DilationFilter::getDilationRadiusOption
DoublePropertyPtr getDilationRadiusOption(QDomElement root)
Definition: cxDilationFilter.cpp:80

cxContourFilter.h

cx::DilationFilter::createInputTypes
virtual void createInputTypes()
Definition: cxDilationFilter.cpp:112

cx::ColorPropertyPtr
boost::shared_ptr< class ColorProperty > ColorPropertyPtr
Definition: cxForwardDeclarations.h:159

cx::DilationFilter::createOptions
virtual void createOptions()
Definition: cxDilationFilter.cpp:105

cx::VisServicesPtr
boost::shared_ptr< class VisServices > VisServicesPtr
Definition: cxMainWindow.h:62

cx::FilterImpl::preProcess
virtual bool preProcess()
Definition: cxFilterImpl.cpp:106

cxMesh.h

cx::StringPropertySelectData::New
static StringPropertySelectDataPtr New(PatientModelServicePtr patientModelService, QString typeRegexp=".*")
Definition: cxSelectDataStringProperty.h:122

cx::DoubleRange
Utility class for describing a bounded numeric range.
Definition: cxDoubleRange.h:53

cx::ImagePtr
boost::shared_ptr< class Image > ImagePtr
Definition: cxDicomWidget.h:48

cx::DilationFilter::postProcess
virtual bool postProcess()
Definition: cxDilationFilter.cpp:201

cx::DilationFilter::execute
virtual bool execute()
Definition: cxDilationFilter.cpp:142

cxImage.h

cx::DilationFilter::getHelp
virtual QString getHelp() const
Definition: cxDilationFilter.cpp:71

cx::DilationFilter::getColorOption
ColorPropertyPtr getColorOption(QDomElement root)
Definition: cxDilationFilter.cpp:97

cxAlgorithmHelpers.h

cxBoolProperty.h

cx::FilterImpl::mOptionsAdapters
std::vector< PropertyPtr > mOptionsAdapters
Definition: cxFilterImpl.h:96

vtkPolyDataPtr
vtkSmartPointer< class vtkPolyData > vtkPolyDataPtr
Definition: cxAirwaysFilterService.h:52

cx::FilterImpl::mServices
VisServicesPtr mServices
Definition: cxFilterImpl.h:103

cx::createDerivedImage
ImagePtr createDerivedImage(PatientModelServicePtr dataManager, QString uid, QString name, vtkImageDataPtr raw, ImagePtr parent)
Definition: cxVolumeHelpers.cpp:170

cx::SelectDataStringPropertyBasePtr
boost::shared_ptr< class SelectDataStringPropertyBase > SelectDataStringPropertyBasePtr
Definition: cxMeshInfoWidget.h:48

cx::ContourFilter::execute
virtual bool execute()
Definition: cxContourFilter.cpp:215

cx::DoublePropertyBase::grSLIDER
Definition: cxDoublePropertyBase.h:102

itk::ImageToVTKImageFilter::Pointer
SmartPointer< Self > Pointer
Definition: itkImageToVTKImageFilter.h:47

cx::FilterImpl::getCopiedInputImage
ImagePtr getCopiedInputImage(int index=0)
Definition: cxFilterImpl.cpp:125

cx::FilterImpl::mOptions
QDomElement mOptions
Definition: cxFilterImpl.h:97

vtkImageCastPtr
vtkSmartPointer< class vtkImageCast > vtkImageCastPtr
Definition: vtkForwardDeclarations.h:88

cx::DoublePropertyPtr
boost::shared_ptr< class DoubleProperty > DoublePropertyPtr
Definition: cxReconstructionMethodService.h:54

cxSelectDataStringProperty.h

cx::FilterImpl::mOutputTypes
std::vector< SelectDataStringPropertyBasePtr > mOutputTypes
Definition: cxFilterImpl.h:95

cxColorProperty.h

cx::FilterImpl
Definition: cxFilterImpl.h:57

cx::DoubleProperty::initialize
static DoublePropertyPtr initialize(const QString &uid, QString name, QString help, double value, DoubleRange range, int decimals, QDomNode root=QDomNode())
Definition: cxDoubleProperty.cpp:51

cx::DilationFilter::getType
virtual QString getType() const
Definition: cxDilationFilter.cpp:66

cxUtilHelpers.h

cx::ContourFilter::postProcess
virtual bool postProcess()
Definition: cxContourFilter.cpp:316

cx::AlgorithmHelper::getITKfromSSCImage
static itkImageType::ConstPointer getITKfromSSCImage(ImagePtr image)
Definition: cxAlgorithmHelpers.cpp:56

cx::StringPropertySelectImage::New
static StringPropertySelectImagePtr New(PatientModelServicePtr patientModelService)
Definition: cxSelectDataStringProperty.h:97

cx::ColorProperty::initialize
static ColorPropertyPtr initialize(const QString &uid, QString name, QString help, QColor value, QDomNode root=QDomNode())
Definition: cxColorProperty.cpp:45

cx::DilationFilter::getGenerateSurfaceOption
BoolPropertyPtr getGenerateSurfaceOption(QDomElement root)
Definition: cxDilationFilter.cpp:89

cx::BoolPropertyPtr
boost::shared_ptr< class BoolProperty > BoolPropertyPtr
Definition: cxNetworkDataTransfer.h:42

cx::MeshPtr
boost::shared_ptr< class Mesh > MeshPtr
Definition: cxForwardDeclarations.h:68

vtkImageDataPtr
vtkSmartPointer< class vtkImageData > vtkImageDataPtr
Definition: cxVideoConnectionWidget.h:51

cxVolumeHelpers.h

cxVisServices.h

cxPatientModelService.h