developer_doc/15.3.4-beta/cx_contour_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 "cxContourFilter.h"


 #include <vtkImageShrink3D.h>

 #include <vtkMarchingCubes.h>

 #include <vtkWindowedSincPolyDataFilter.h>

 #include <vtkTriangleFilter.h>

 #include <vtkDecimatePro.h>

 #include <vtkPolyDataNormals.h>

 #include <vtkImageData.h>


 #include "cxRegistrationTransform.h"

 #include "cxTypeConversions.h"

 #include "cxImage.h"

 #include "cxMesh.h"

 #include "cxDoubleProperty.h"

 #include "cxBoolProperty.h"

 #include "cxColorProperty.h"

 #include "cxSelectDataStringProperty.h"

 #include "cxPatientModelService.h"

 #include "cxViewService.h"

 #include "cxVisServices.h"


 namespace cx

 {


 ContourFilter::ContourFilter(VisServicesPtr services) :

         FilterImpl(services)

 {

 }


 QString ContourFilter::getName() const

 {

         return "Contour";

 }


 QString ContourFilter::getType() const

 {

         return "ContourFilter";

 }


 QString ContourFilter::getHelp() const

 {

         return "<html>"

                 "<h3>Surfacing.</h3>"

                 "<p><i>Find the surface of a binary volume using marching cubes.</i></p>"

                 "<p>- Optional factor 2 reduction</p>"

                 "<p>- Marching Cubes contouring</p>"

                 "<p>- Optional Windowed Sinc smoothing</p>"

                 "<p>- Decimation of triangles</p>"

                 "</html>";

 }


 BoolPropertyPtr ContourFilter::getReduceResolutionOption(QDomElement root)

 {

         return BoolProperty::initialize("Reduce input", "",

                                                    "Reduce input volumes resolution by a factor of 2 in all directions.", false, root);

 }


 BoolPropertyPtr ContourFilter::getSmoothingOption(QDomElement root)

 {

         return BoolProperty::initialize("Smoothing", "",

                                                    "Smooth the output contour", true, root);

 }


 BoolPropertyPtr ContourFilter::getPreserveTopologyOption(QDomElement root)

 {

         return BoolProperty::initialize("Preserve mesh topology", "",

                                                    "Preserve mesh topology during reduction", true, root);

 }


 DoublePropertyPtr ContourFilter::getSurfaceThresholdOption(QDomElement root)

 {

         DoublePropertyPtr retval = DoubleProperty::initialize("Threshold", "",

                                                                                     "Values from this threshold and above will be included",

                                                                                     100.0, DoubleRange(-1000, 1000, 1), 0, root);

         retval->setGuiRepresentation(DoublePropertyBase::grSLIDER);

         return retval;

 }


 DoublePropertyPtr ContourFilter::getDecimationOption(QDomElement root)

 {

         DoublePropertyPtr retval = DoubleProperty::initialize("Decimation %", "",

                                                                                     "Reduce number of triangles in output surface",

                                                                                     0.2, DoubleRange(0, 1, 0.01), 0, root);

         retval->setInternal2Display(100);

         return retval;

 }


 ColorPropertyPtr ContourFilter::getColorOption(QDomElement root)

 {

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

                                                     "Color of output model.",

                                                     QColor("green"), root);

 }


 void ContourFilter::createOptions()

 {

         mReduceResolutionOption = this->getReduceResolutionOption(mOptions);

         mOptionsAdapters.push_back(mReduceResolutionOption);


         mSurfaceThresholdOption = this->getSurfaceThresholdOption(mOptions);

         connect(mSurfaceThresholdOption.get(), SIGNAL(changed()), this, SLOT(thresholdSlot()));

         mOptionsAdapters.push_back(mSurfaceThresholdOption);


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

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

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


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

 }


 void ContourFilter::createInputTypes()

 {

         SelectDataStringPropertyBasePtr temp;


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

         temp->setValueName("Input");

         temp->setHelp("Select image input for contouring");

         connect(temp.get(), SIGNAL(dataChanged(QString)), this, SLOT(imageChangedSlot(QString)));

         mInputTypes.push_back(temp);

 }


 void ContourFilter::createOutputTypes()

 {

         SelectDataStringPropertyBasePtr temp;


         temp = StringPropertySelectMesh::New(mServices->getPatientService());

         temp->setValueName("Output");

         temp->setHelp("Output contour");

         mOutputTypes.push_back(temp);

 }


 void ContourFilter::setActive(bool on)

 {

         FilterImpl::setActive(on);


         if (!mActive)

                 mServices->visualizationService->removePreview();

 }


 void ContourFilter::imageChangedSlot(QString uid)

 {

         ImagePtr image = mServices->getPatientService()->getData<Image>(uid);

         if(!image)

                 return;


         this->updateThresholdFromImageChange(uid, mSurfaceThresholdOption);

         mServices->visualizationService->removePreview();


         int extent[6];

         image->getBaseVtkImageData()->GetExtent(extent);

         mReduceResolutionOption->setHelp("Current input resolution: " + qstring_cast(extent[1])

                                          + " " + qstring_cast(extent[3]) + " " + qstring_cast(extent[5])

                                          + " (If checked: " + qstring_cast(extent[1]/2)+ " " + qstring_cast(extent[3]/2) + " "

                                          + qstring_cast(extent[5]/2) + ")");

 }


 void ContourFilter::thresholdSlot()

 {

         if (mActive)

         {

                 ImagePtr image = boost::dynamic_pointer_cast<Image>(mInputTypes[0]->getData());

                 std::vector<double> threshold;

                 threshold.push_back(mSurfaceThresholdOption->getValue());

                 mServices->visualizationService->setPreview(image, threshold);

         }

 }


 bool ContourFilter::preProcess()

 {

         mServices->visualizationService->removePreview();

         return FilterImpl::preProcess();

 }


 bool ContourFilter::execute()

 {

         ImagePtr input = this->getCopiedInputImage();

         if (!input)

                 return false;


         //    std::cout << "ContourFilter::execute : " << mCopiedOptions.ownerDocument().toString() << std::endl;


         BoolPropertyPtr reduceResolutionOption = this->getReduceResolutionOption(mCopiedOptions);

         BoolPropertyPtr smoothingOption = this->getSmoothingOption(mCopiedOptions);

         BoolPropertyPtr preserveTopologyOption = this->getPreserveTopologyOption(mCopiedOptions);

         DoublePropertyPtr surfaceThresholdOption = this->getSurfaceThresholdOption(mCopiedOptions);

         DoublePropertyPtr decimationOption = this->getDecimationOption(mCopiedOptions);


         //    report(QString("Creating contour from \"%1\"...").arg(input->getName()));


         mRawResult = this->execute(input->getBaseVtkImageData(),

                                    surfaceThresholdOption->getValue(),

                                    reduceResolutionOption->getValue(),

                                    smoothingOption->getValue(),

                                    preserveTopologyOption->getValue(),

                                    decimationOption->getValue());

         return true;

 }


 vtkPolyDataPtr ContourFilter::execute(vtkImageDataPtr input,

                                       double threshold,

                                       bool reduceResolution,

                                       bool smoothing,

                                       bool preserveTopology,

                                       double decimation)

 {

         if (!input)

                 return vtkPolyDataPtr();


         //Shrink input volume

         vtkImageShrink3DPtr shrinker = vtkImageShrink3DPtr::New();

         if(reduceResolution)

         {

 //              std::cout << "smooth" << std::endl;

                 shrinker->SetInputData(input);

                 shrinker->SetShrinkFactors(2,2,2);

                 shrinker->Update();

         }


         // Find countour

         vtkMarchingCubesPtr convert = vtkMarchingCubesPtr::New();

         if(reduceResolution)

                 convert->SetInputConnection(shrinker->GetOutputPort());

         else

                 convert->SetInputData(input);


         convert->SetValue(0, threshold);

         convert->Update();


         vtkPolyDataPtr cubesPolyData = convert->GetOutput();

 //      vtkPolyDataPtr cubesPolyData = vtkPolyDataPtr::New();

 //      cubesPolyData = convert->GetOutput();

 //      std::cout << "convert->GetOutput(); " << cubesPolyData.GetPointer() << std::endl;


         // Smooth surface model

         vtkWindowedSincPolyDataFilterPtr smoother = vtkWindowedSincPolyDataFilterPtr::New();

         if(smoothing)

         {

                 smoother->SetInputData(cubesPolyData);

                 smoother->SetNumberOfIterations(15);// Higher number = more smoothing

                 smoother->SetBoundarySmoothing(false);

                 smoother->SetFeatureEdgeSmoothing(false);

                 smoother->SetNormalizeCoordinates(true);

                 smoother->SetFeatureAngle(120);

                 smoother->SetPassBand(0.3);//Lower number = more smoothing

                 smoother->Update();

                 cubesPolyData = smoother->GetOutput();

         }


         //Create a surface of triangles


         //Decimate surface model (remove a percentage of the polygons)

         vtkTriangleFilterPtr trifilt = vtkTriangleFilterPtr::New();

         vtkDecimateProPtr deci = vtkDecimateProPtr::New();

         vtkPolyDataNormalsPtr normals = vtkPolyDataNormalsPtr::New();

         if (decimation > 0.000001)

         {

                 trifilt->SetInputData(cubesPolyData);

                 trifilt->Update();

                 deci->SetInputConnection(trifilt->GetOutputPort());

                 deci->SetTargetReduction(decimation);

                 deci->SetPreserveTopology(preserveTopology);

                 //    deci->PreserveTopologyOn();

                 deci->Update();

                 cubesPolyData = deci->GetOutput();

         }


         normals->SetInputData(cubesPolyData);

         normals->Update();


         cubesPolyData->DeepCopy(normals->GetOutput());


         return cubesPolyData;

 }


 bool ContourFilter::postProcess()

 {

         if (!mRawResult)

                 return false;


         ImagePtr input = this->getCopiedInputImage();


         if (!input)

                 return false;


         ColorPropertyPtr colorOption = this->getColorOption(mOptions);

         MeshPtr output = this->postProcess(mServices->getPatientService(), mRawResult, input, colorOption->getValue());

         mRawResult = NULL;


         if (output)

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


         return true;

 }


 MeshPtr ContourFilter::postProcess(PatientModelServicePtr patient, vtkPolyDataPtr contour, ImagePtr base, QColor color)

 {

         if (!contour || !base)

                 return MeshPtr();


         QString uid = base->getUid() + "_ge%1";

         QString name = base->getName()+" ge%1";

         MeshPtr output = patient->createSpecificData<Mesh>(uid, name);

         output->setVtkPolyData(contour);

         if (!output)

                 return MeshPtr();


         output->get_rMd_History()->setRegistration(base->get_rMd());

         output->get_rMd_History()->setParentSpace(base->getUid());


         output->setColor(color);


         patient->insertData(output);


         return output;

 }


 } // namespace cx

qstring_cast
QString qstring_cast(const T &val)
Definition: cxTypeConversions.h:67

cxDoubleProperty.h

vtkDecimateProPtr
vtkSmartPointer< class vtkDecimatePro > vtkDecimateProPtr
Definition: vtkForwardDeclarations.h:73

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

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

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

cx::Mesh
A mesh data set.
Definition: cxMesh.h:61

cx::ContourFilter::getSurfaceThresholdOption
DoublePropertyPtr getSurfaceThresholdOption(QDomElement root)
Definition: cxContourFilter.cpp:104

vtkMarchingCubesPtr
vtkSmartPointer< class vtkMarchingCubes > vtkMarchingCubesPtr
Definition: vtkForwardDeclarations.h:107

cxContourFilter.h

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

cx::ContourFilter::createOptions
virtual void createOptions()
Definition: cxContourFilter.cpp:129

cx::FilterImpl::mActive
bool mActive
Definition: cxFilterImpl.h:102

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

cx::ContourFilter::setActive
virtual void setActive(bool on)
Definition: cxContourFilter.cpp:166

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

cxMesh.h

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

vtkWindowedSincPolyDataFilterPtr
vtkSmartPointer< class vtkWindowedSincPolyDataFilter > vtkWindowedSincPolyDataFilterPtr
Definition: vtkForwardDeclarations.h:158

cxTypeConversions.h

cxImage.h

vtkPolyDataPtr
vtkSmartPointer< class vtkPolyData > vtkPolyDataPtr
Definition: cxProbeSector.h:47

cx::ContourFilter::getColorOption
ColorPropertyPtr getColorOption(QDomElement root)
Definition: cxContourFilter.cpp:122

cxBoolProperty.h

cx::ContourFilter::getPreserveTopologyOption
BoolPropertyPtr getPreserveTopologyOption(QDomElement root)
Definition: cxContourFilter.cpp:98

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

cx::SelectDataStringPropertyBasePtr
boost::shared_ptr< class SelectDataStringPropertyBase > SelectDataStringPropertyBasePtr
Definition: cxSelectDataStringPropertyBase.h:43

cx::ContourFilter::createInputTypes
virtual void createInputTypes()
Definition: cxContourFilter.cpp:145

cx::ContourFilter::getHelp
virtual QString getHelp() const
Definition: cxContourFilter.cpp:74

cxRegistrationTransform.h

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

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

cx::Mesh::setVtkPolyData
void setVtkPolyData(const vtkPolyDataPtr &polyData)
Definition: cxMesh.cpp:94

cx::ContourFilter::getType
virtual QString getType() const
Definition: cxContourFilter.cpp:69

cx::ContourFilter::createOutputTypes
virtual void createOutputTypes()
Definition: cxContourFilter.cpp:156

cx::ContourFilter::getSmoothingOption
BoolPropertyPtr getSmoothingOption(QDomElement root)
Definition: cxContourFilter.cpp:92

cx::Image
A volumetric data set.
Definition: cxImage.h:64

vtkPolyDataNormalsPtr
vtkSmartPointer< class vtkPolyDataNormals > vtkPolyDataNormalsPtr
Definition: vtkForwardDeclarations.h:124

cx::ContourFilter::getDecimationOption
DoublePropertyPtr getDecimationOption(QDomElement root)
Definition: cxContourFilter.cpp:113

cx::PatientModelServicePtr
boost::shared_ptr< class PatientModelService > PatientModelServicePtr
Definition: cxLegacySingletons.h:44

cx::ContourFilter::ContourFilter
ContourFilter(VisServicesPtr services)
Definition: cxContourFilter.cpp:59

vtkTriangleFilterPtr
vtkSmartPointer< class vtkTriangleFilter > vtkTriangleFilterPtr
Definition: vtkForwardDeclarations.h:149

cx::ContourFilter::preProcess
bool preProcess()
Definition: cxContourFilter.cpp:202

vtkImageShrink3DPtr
vtkSmartPointer< class vtkImageShrink3D > vtkImageShrink3DPtr
Definition: vtkForwardDeclarations.h:98

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

cx::FilterImpl::setActive
virtual void setActive(bool on)
Definition: cxFilterImpl.cpp:100

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

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

cx::ContourFilter::getName
virtual QString getName() const
Definition: cxContourFilter.cpp:64

cx::ContourFilter::getReduceResolutionOption
BoolPropertyPtr getReduceResolutionOption(QDomElement root)
Definition: cxContourFilter.cpp:86

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::StringPropertySelectMesh::New
static StringPropertySelectMeshPtr New(PatientModelServicePtr patientModelService)
Definition: cxSelectDataStringProperty.h:120

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

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

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

cx::BoolPropertyPtr
boost::shared_ptr< class BoolProperty > BoolPropertyPtr
Definition: cxForwardDeclarations.h:157

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

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

cx::FilterImpl::updateThresholdFromImageChange
void updateThresholdFromImageChange(QString uid, DoublePropertyPtr threshold)
Definition: cxFilterImpl.cpp:132

cxVisServices.h

cx::Filter::changed
void changed()

cxPatientModelService.h

cxViewService.h