developer_doc/17.12/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 "contour_filter";
 }

 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>";
 }

 QString ContourFilter::getNameSuffix()
 {
     return "_ge";
 }

 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->patient());
         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->patient());
         temp->setValueName("Output");
         temp->setHelp("Output contour");
         mOutputTypes.push_back(temp);
 }

 void ContourFilter::setActive(bool on)
 {
         FilterImpl::setActive(on);

         if (!mActive)
                 this->stopPreview();
 }

 void ContourFilter::stopPreview()
 {
         if(mPreviewImage)
                 mPreviewImage->stopThresholdPreview();
         mPreviewImage.reset();
 }

 void ContourFilter::imageChangedSlot(QString uid)
 {
         ImagePtr image = mServices->patient()->getData<Image>(uid);
         if(!image)
                 return;

         this->updateThresholdFromImageChange(uid, mSurfaceThresholdOption);
         this->stopPreview();

         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)
         {
                 mPreviewImage = boost::dynamic_pointer_cast<Image>(mInputTypes[0]->getData());
                 if(mPreviewImage)
                 {
                         Eigen::Vector2d threshold = Eigen::Vector2d(mSurfaceThresholdOption->getValue(),  mPreviewImage->getMax());
                         mPreviewImage->startThresholdPreview(threshold);
                 }
         }
 }

 bool ContourFilter::preProcess()
 {
         this->stopPreview();
         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->patient(), 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() + ContourFilter::getNameSuffix() + "%1";
     QString name = base->getName()+ ContourFilter::getNameSuffix() + "%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:75

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:66

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

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

cxContourFilter.h

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

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

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:171

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:173

cxTypeConversions.h

cxImage.h

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

cxBoolProperty.h

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

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

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

cx::SelectDataStringPropertyBasePtr
boost::shared_ptr< class SelectDataStringPropertyBase > SelectDataStringPropertyBasePtr
Definition: cxMeshGlyphsWidget.h:47

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

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

cxRegistrationTransform.h

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

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

cx::ContourFilter::getNameSuffix
static QString getNameSuffix()
Definition: cxContourFilter.cpp:86

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

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

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

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

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

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

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

cx::PatientModelServicePtr
boost::shared_ptr< class PatientModelService > PatientModelServicePtr
Definition: cxLogicManager.h:46

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

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

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

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

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::vtkPolyDataPtr
vtkSmartPointer< vtkPolyData > vtkPolyDataPtr
Definition: cxCenterlineRegistration.h:63

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:91

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:152

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

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::BoolPropertyPtr
boost::shared_ptr< class BoolProperty > BoolPropertyPtr
Definition: cxNetworkDataTransfer.h:42

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

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

cx
Namespace for all CustusX production code.
Definition: cx_dev_group_definitions.h:34

cxViewService.h