developer_doc/18.04/cx_contour_filter_8cpp_source.html

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

 Copyright (c) SINTEF Department of Medical Technology.
 All rights reserved.

 CustusX is released under a BSD 3-Clause license.

 See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
 =========================================================================*/

 #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:46

cxDoubleProperty.h

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

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

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

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

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

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

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

cxContourFilter.h

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

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

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

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

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

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

cxMesh.h

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

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

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

cxTypeConversions.h

cxImage.h

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

cxBoolProperty.h

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

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

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

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

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

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

cxRegistrationTransform.h

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

cx::vtkPolyDataPtr
vtkSmartPointer< vtkPolyData > vtkPolyDataPtr
Definition: cxCenterlineRegistration.h:42

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

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

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

cxSelectDataStringProperty.h

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

cxColorProperty.h

cx::FilterImpl
Definition: cxFilterImpl.h:36

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

cx::StringPropertySelectMesh::New
static StringPropertySelectMeshPtr New(PatientModelServicePtr patientModelService)
Definition: cxSelectDataStringProperty.h:131

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

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

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

cx::BoolPropertyPtr
boost::shared_ptr< class BoolProperty > BoolPropertyPtr
Definition: cxPlusConnectWidget.h:29

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

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

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

cxVisServices.h

cx::Filter::changed
void changed()

cxPatientModelService.h

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

cxViewService.h