35 #include "tube-segmentation.hpp"
36 #include "tsf-config.h"
37 #include "Exceptions.hpp"
41 #include <vtkImageImport.h>
42 #include <vtkImageData.h>
43 #include <vtkImageShiftScale.h>
44 #include <ctkPluginContext.h>
65 connect(
patientService().
get(), SIGNAL(patientChanged()),
this, SLOT(patientChangedSlot()));
66 mPresets = this->populatePresets();
71 return "Tube-Segmentation Filter";
76 return "TubeSegmentationFilter";
82 "<h3>Tube-Segmentation.</h3>"
83 "<p><i>Extracts the centerline and creates a segmentation. </br>GPU-based algorithm written by Erik Smistad (NTNU).</i></p>"
99 std::vector<PropertyPtr> newPresetOptions = this->getNotDefaultOptions();
101 std::map<QString, QString> newPresetMap;
102 std::vector<PropertyPtr>::iterator it;
103 for(it = newPresetOptions.begin(); it != newPresetOptions.end(); ++it){
105 QString valuename = option->getDisplayName();
113 value = boolOption->getValue() ?
"true" :
"false";
114 else if(doubleOption)
115 value = QString::number(doubleOption->getValue());
117 reportError(
"Could not determine what kind of option to get the value for.");
118 newPresetMap[valuename] = value;
121 newPresetMap[centerlineMethod->getDisplayName()] = centerlineMethod->getValue();
131 QString centerLineMethod =
"gpu";
132 if((name ==
"<Default preset>") || (name ==
"none") || (name ==
"default") || (name ==
"Default"))
133 mParameterFile =
"none";
136 mParameterFile = name;
138 this->loadNewParametersSlot();
140 StringPropertyPtr centerlineMethodOption = this->getStringOption(
"centerline-method");
141 centerlineMethodOption->setValue(centerLineMethod);
150 mParameters = this->getParametersFromOptions();
151 std::string filename = (
patientService()->getActivePatientFolder()+
"/"+input->getFilename()).toStdString();
154 std::cout <<
"=================TSF START====================" << std::endl;
155 std::cout <<
"Input: " << input->getName().toStdString() << std::endl;
156 std::cout <<
"Preset: " << getParamStr(mParameters,
"parameters") << std::endl;
157 std::cout <<
"Centerline-method: " << getParamStr(mParameters,
"centerline-method") << std::endl;
160 std::cout <<
"Kernel paths: " << kernelDir.toStdString();
161 std::cout <<
" and " << oulDir.toStdString() << std::endl;
162 std::cout <<
"--------------" << std::endl;
163 mOutput = run(filename, mParameters, kernelDir.toStdString(), oulDir.toStdString());
164 std::cout <<
"=================TSF END====================" << std::endl;
165 }
catch(SIPL::SIPLException& e) {
166 std::string error = e.what();
174 }
catch(cl::Error& e) {
182 }
catch (std::exception& e){
191 reportError(
"Tube segmentation algorithm threw a unknown exception.");
206 reportWarning(
"No output generated from the tube segmentation filter.");
214 double inputImageSpacing_x, inputImageSpacing_y, inputImageSpacing_z;
215 inputImage->getBaseVtkImageData()->GetSpacing(inputImageSpacing_x, inputImageSpacing_y, inputImageSpacing_z);
218 SIPL::int3 voxelsCropped = mOutput->getShiftVector();
219 Vector3D croppingVectorInInpuImageSpace((inputImageSpacing_x*voxelsCropped.x), (inputImageSpacing_y*voxelsCropped.y), (inputImageSpacing_z*voxelsCropped.z));
226 if(mOutput->hasCenterlineVoxels())
228 QString uidCenterline = inputImage->getUid() +
"_tsf_cl_vol%1";
229 QString nameCenterline = inputImage->getName()+
"_tsf_cl_vol%1";
230 SIPL::int3* size = mOutput->getSize();
231 vtkImageDataPtr rawCenterlineResult = this->convertToVtkImageData(mOutput->getCenterlineVoxels(), size->x, size->y, size->z, inputImage);
232 if(!rawCenterlineResult)
238 outputCenterline->setVtkImageData(rawCenterlineResult);
240 if (!outputCenterline)
243 outputCenterline->get_rMd_History()->setRegistration(rMd_c);
254 boost::unordered_map<std::string, StringParameter>::iterator it = mParameters.strings.find(
"centerline-vtk-file");
255 if(it != mParameters.strings.end() && (it->second.get() !=
"off"))
257 QString tsfVtkFilename =
qstring_cast(it->second.get());
258 QString uidVtkCenterline = inputImage->getUid() +
"_tsf_cl%1";
259 QString nameVtkCenterline = inputImage->getName()+
"_tsf_cl%1";
262 MeshPtr tsfMesh = this->loadVtkFile(tsfVtkFilename, uidVtkCenterline);
264 Vector3D inpuImageSpacing(inputImageSpacing_x, inputImageSpacing_y, inputImageSpacing_z);
274 cxMesh->get_rMd_History()->setParentSpace(inputImage->getUid());
278 QString uid = cxMesh->getUid();
285 if(mOutput->hasSegmentation())
288 SIPL::int3* size = mOutput->getSize();
289 vtkImageDataPtr rawSegmentation = this->convertToVtkImageData(mOutput->getSegmentation(), size->x, size->y, size->z, inputImage);
292 double threshold = 1;
296 QString uidSegmentation = inputImage->getUid() +
"_tsf_seg%1";
297 QString nameSegmentation = inputImage->getName()+
"_tsf_seg%1";
301 outputSegmentation->setVtkImageData(rawSegmentation);
303 if (!outputSegmentation)
306 outputSegmentation->get_rMd_History()->setRegistration(rMd_c);
313 contour->get_rMd_History()->setRegistration(rMd_c);
316 mOutputTypes[2]->setValue(outputSegmentation->getUid());
322 if(mOutput->hasTDF())
324 QString uidTDF = inputImage->getUid() +
"_tsf_tdf%1";
325 QString nameTDF = inputImage->getName()+
"_tsf_tdf%1";
326 SIPL::int3* size = mOutput->getSize();
329 vtkImageDataPtr convertedImageData = this->convertToVtkImageData(mOutput->getTDF(), size->x, size->y, size->z, inputImage);
332 if (!convertedImageData)
336 cast->SetInputData(convertedImageData);
337 cast->ClampOverflowOn();
342 cast->SetScale(scale);
343 cast->SetOutputScalarType(VTK_UNSIGNED_CHAR);
345 convertedImageData = cast->GetOutput();
350 outputTDF->setVtkImageData(convertedImageData);
356 rMd_i = rMd_i * d_iMd_c;
357 outputTDF->get_rMd_History()->setRegistration(rMd_i);
376 this->createDefaultOptions(
mOptions);
378 std::vector<StringPropertyPtr>::iterator stringIt;
379 for(stringIt = mStringOptions.begin(); stringIt != mStringOptions.end(); ++stringIt)
382 std::vector<BoolPropertyPtr>::iterator boolIt;
383 for(boolIt = mBoolOptions.begin(); boolIt != mBoolOptions.end(); ++boolIt)
386 std::vector<DoublePropertyPtr>::iterator doubleIt;
387 for(doubleIt = mDoubleOptions.begin(); doubleIt != mDoubleOptions.end(); ++doubleIt)
396 temp->setValueName(
"Input");
397 temp->setHelp(
"Select input to run Tube segmentation on.");
400 connect(temp.get(), SIGNAL(
changed()),
this, SLOT(inputChangedSlot()));
410 tempDataStringAdapter->setValueName(
"Centerline volume");
411 tempDataStringAdapter->setHelp(
"Generated centerline volume.");
416 tempMeshStringAdapter->setValueName(
"Centerline mesh");
417 tempMeshStringAdapter->setHelp(
"Generated centerline mesh (vtk-format).");
422 tempDataStringAdapter->setValueName(
"Segmented centerline");
423 tempDataStringAdapter->setHelp(
"Grown segmentation from the centerline.");
428 tempMeshStringAdapter->setValueName(
"Segmented centerlines surface");
429 tempMeshStringAdapter->setHelp(
"Generated surface of the segmented volume.");
434 tempDataStringAdapter->setValueName(
"TDF volume");
435 tempDataStringAdapter->setHelp(
"Volume showing the probability of a voxel being part of a tubular structure.");
439 void TubeSegmentationFilter::patientChangedSlot()
441 QString activePatientFolder =
patientService()->getActivePatientFolder()+
"/Images/";
445 option->setValue(activePatientFolder);
448 void TubeSegmentationFilter::inputChangedSlot()
450 QString activePatientFolder =
patientService()->getActivePatientFolder()+
"/Images/";
451 QString inputsValue =
mInputTypes.front()->getValue();
455 option->setValue(activePatientFolder+inputsValue+QDateTime::currentDateTime().toString(
timestampSecondsFormat())+
"_tsf_vtk.vtk");
458 void TubeSegmentationFilter::loadNewParametersSlot()
460 paramList list = this->getDefaultParameters();
462 if(mParameterFile !=
"none")
466 setParameter(list,
"parameters", mParameterFile.toStdString());
468 }
catch (SIPL::SIPLException& e)
470 reportWarning(
"Error when loading a parameter file. Preset is corrupt. "+QString(e.what()));
476 this->setOptionsSlot(list);
477 this->resetOptionsAdvancedSlot();
479 std::vector<std::string> notDefaultOptions = this->getNotDefault(list);
480 std::vector<std::string>::iterator it;
481 for(it = notDefaultOptions.begin() ;it != notDefaultOptions.end(); ++it)
490 void TubeSegmentationFilter::resetOptionsAdvancedSlot()
492 std::vector<StringPropertyPtr>::iterator stringIt;
493 for(stringIt = mStringOptions.begin(); stringIt != mStringOptions.end(); ++stringIt)
496 if(adapter->getDisplayName() ==
"parameters")
498 adapter->setAdvanced(
false);
501 adapter->setAdvanced(
true);
504 std::vector<BoolPropertyPtr>::iterator boolIt;
505 for(boolIt = mBoolOptions.begin(); boolIt != mBoolOptions.end(); ++boolIt)
508 adapter->setAdvanced(
true);
511 std::vector<DoublePropertyPtr>::iterator doubleIt;
512 for(doubleIt = mDoubleOptions.begin(); doubleIt != mDoubleOptions.end(); ++doubleIt)
515 adapter->setAdvanced(
true);
519 void TubeSegmentationFilter::resetOptionsSlot()
521 paramList defaultParameters = this->getDefaultParameters();
522 this->resetOptionsAdvancedSlot();
523 this->setOptionsSlot(defaultParameters);
526 void TubeSegmentationFilter::setOptionsSlot(paramList& list)
528 this->setParamtersToOptions(list);
529 this->patientChangedSlot();
530 this->inputChangedSlot();
534 vtkImageDataPtr TubeSegmentationFilter::convertToVtkImageData(
char * data,
int size_x,
int size_y,
int size_z,
ImagePtr input)
537 return vtkImageDataPtr::New();
539 vtkImageDataPtr retval = this->importRawImageData((
void*) data, size_x, size_y, size_z, input, VTK_UNSIGNED_CHAR);
543 vtkImageDataPtr TubeSegmentationFilter::convertToVtkImageData(
float * data,
int size_x,
int size_y,
int size_z,
ImagePtr input)
546 return vtkImageDataPtr::New();
548 vtkImageDataPtr retval = this->importRawImageData((
void*) data, size_x, size_y, size_z, input, VTK_FLOAT);
567 vtkImageDataPtr TubeSegmentationFilter::importRawImageData(
void * data,
int size_x,
int size_y,
int size_z,
ImagePtr input,
int type)
571 imageImport->SetWholeExtent(0, size_x - 1, 0, size_y - 1, 0, size_z - 1);
572 imageImport->SetDataExtentToWholeExtent();
573 imageImport->SetDataScalarType(type);
574 imageImport->SetNumberOfScalarComponents(1);
575 imageImport->SetDataSpacing(input->getBaseVtkImageData()->GetSpacing());
576 imageImport->SetImportVoidPointer(data);
578 imageImport->Update();
579 imageImport->Modified();
582 retval->DeepCopy(imageImport->GetOutput());
587 MeshPtr TubeSegmentationFilter::loadVtkFile(QString pathToFile, QString newDatasUid){
588 PolyDataMeshReader reader;
590 if(reader.canLoad(
"vtk", pathToFile))
591 data = reader.load(newDatasUid, pathToFile);
593 MeshPtr retval = boost::dynamic_pointer_cast<Mesh>(data);
601 void TubeSegmentationFilter::createDefaultOptions(QDomElement root)
604 paramList defaultOptions = this->getDefaultParameters();
607 boost::unordered_map<std::string, StringParameter>::iterator stringIt;
608 for(stringIt = defaultOptions.strings.begin(); stringIt != defaultOptions.strings.end(); ++stringIt )
610 StringPropertyPtr option = this->makeStringOption(root, stringIt->first, stringIt->second);
611 option->setAdvanced(
true);
612 option->setGroup(
qstring_cast(stringIt->second.getGroup()));
613 mStringOptions.push_back(option);
614 if(stringIt->first ==
"parameters")
615 option->setEnabled(
false);
616 option->setAdvanced(
true);
620 boost::unordered_map<std::string, BoolParameter>::iterator boolIt;
621 for(boolIt = defaultOptions.bools.begin(); boolIt != defaultOptions.bools.end(); ++boolIt )
623 BoolPropertyPtr option = this->makeBoolOption(root, boolIt->first, boolIt->second);
624 option->setAdvanced(
true);
625 option->setGroup(
qstring_cast(boolIt->second.getGroup()));
626 mBoolOptions.push_back(option);
630 boost::unordered_map<std::string, NumericParameter>::iterator numericIt;
631 for(numericIt = defaultOptions.numerics.begin(); numericIt != defaultOptions.numerics.end(); ++numericIt )
633 DoublePropertyPtr option = this->makeDoubleOption(root, numericIt->first, numericIt->second);
634 option->setAdvanced(
true);
635 option->setGroup(
qstring_cast(numericIt->second.getGroup()));
636 mDoubleOptions.push_back(option);
640 paramList TubeSegmentationFilter::getParametersFromOptions()
642 paramList retval = this->getDefaultParameters();
644 std::vector<StringPropertyPtr>::iterator stringIt;
645 for(stringIt = mStringOptions.begin(); stringIt != mStringOptions.end(); ++stringIt)
648 setParameter(retval, stringIt->get()->getDisplayName().toStdString(), stringIt->get()->getValue().toStdString());
649 }
catch(SIPL::SIPLException& e){
650 std::string message =
"Could not process a string parameter: \""+std::string(e.what())+
"\"";
656 std::vector<BoolPropertyPtr>::iterator boolIt;
657 for(boolIt = mBoolOptions.begin(); boolIt != mBoolOptions.end(); ++boolIt)
660 std::string value = boolIt->get()->getValue() ?
"true" :
"false";
661 setParameter(retval, boolIt->get()->getDisplayName().toStdString(), value);
662 }
catch(SIPL::SIPLException& e){
663 std::string message =
"Could not process a bool parameter: \""+std::string(e.what())+
"\"";
669 std::vector<DoublePropertyPtr>::iterator doubleIt;
670 for(doubleIt = mDoubleOptions.begin(); doubleIt != mDoubleOptions.end(); ++doubleIt)
673 double dbl = doubleIt->get()->getValue();
674 std::string value = boost::lexical_cast<std::string>(dbl);
675 setParameter(retval, doubleIt->get()->getDisplayName().toStdString(), value);
676 }
catch(SIPL::SIPLException& e){
677 std::string message =
"Could not process a double parameter: \""+std::string(e.what())+
"\"";
684 void TubeSegmentationFilter::setParamtersToOptions(paramList& parameters)
687 boost::unordered_map<std::string, StringParameter>::iterator stringIt;
688 for(stringIt = parameters.strings.begin(); stringIt != parameters.strings.end(); ++stringIt )
692 boost::unordered_map<std::string, BoolParameter>::iterator boolIt;
693 for(boolIt = parameters.bools.begin(); boolIt != parameters.bools.end(); ++boolIt )
697 boost::unordered_map<std::string, NumericParameter>::iterator numericIt;
698 for(numericIt = parameters.numerics.begin(); numericIt != parameters.numerics.end(); ++numericIt )
705 std::vector<StringPropertyPtr>::iterator stringIt;
706 for(stringIt = mStringOptions.begin(); stringIt != mStringOptions.end(); ++stringIt)
708 if(stringIt->get()->getDisplayName().compare(valueName) == 0)
717 BoolPropertyPtr TubeSegmentationFilter::getBoolOption(QString valueName)
720 std::vector<BoolPropertyPtr>::iterator boolIt;
721 for(boolIt = mBoolOptions.begin(); boolIt != mBoolOptions.end(); ++boolIt)
723 if(boolIt->get()->getDisplayName().compare(valueName) == 0)
735 std::vector<DoublePropertyPtr>::iterator doubleIt;
736 for(doubleIt = mDoubleOptions.begin(); doubleIt != mDoubleOptions.end(); ++doubleIt)
738 if(doubleIt->get()->getDisplayName().compare(valueName) == 0)
747 PropertyPtr TubeSegmentationFilter::getOption(QString valueName)
751 retval = getStringOption(valueName);
754 retval = getBoolOption(valueName);
757 retval = getDoubleOption(valueName);
764 void TubeSegmentationFilter::setOptionAdvanced(QString valueName,
bool advanced)
767 option->setAdvanced(advanced);
770 void TubeSegmentationFilter::setOptionValue(QString valueName, QString value)
776 StringPropertyPtr stringOption = boost::dynamic_pointer_cast<StringProperty>(option);
777 BoolPropertyPtr boolOption = boost::dynamic_pointer_cast<BoolProperty>(option);
778 DoublePropertyPtr doubleOption = boost::dynamic_pointer_cast<DoubleProperty>(option);
781 stringOption->setValue(value);
785 bool boolValue = (value.compare(
"1") == 0) ?
true :
false;
786 boolOption->setValue(boolValue);
788 else if(doubleOption)
790 doubleOption->setValue(value.toDouble());
794 reportError(
"Could not determine what kind of option to set the value for.");
799 std::vector<std::string> TubeSegmentationFilter::getNotDefault(paramList list)
801 return this->getDifference(this->getDefaultParameters(), list);
804 std::vector<std::string> TubeSegmentationFilter::getDifference(paramList list1, paramList list2)
806 std::vector<std::string> retval;
808 boost::unordered_map<std::string, StringParameter>::iterator stringIt;
809 for(stringIt = list1.strings.begin(); stringIt != list1.strings.end(); ++stringIt )
811 std::string name = stringIt->first;
812 if(getParamStr(list1, name) != getParamStr(list2, name))
813 retval.push_back(name);
815 boost::unordered_map<std::string, BoolParameter>::iterator boolIt;
816 for(boolIt = list1.bools.begin(); boolIt != list1.bools.end(); ++boolIt )
818 std::string name = boolIt->first;
819 if(getParamBool(list1, name) != getParamBool(list2, name))
820 retval.push_back(name);
822 boost::unordered_map<std::string, NumericParameter>::iterator numericIt;
823 for(numericIt = list1.numerics.begin(); numericIt != list1.numerics.end(); ++numericIt )
825 std::string name = numericIt->first;
826 if(getParam(list1, name) != getParam(list2, name))
827 retval.push_back(name);
830 }
catch (SIPL::SIPLException& e){
837 std::vector<PropertyPtr> TubeSegmentationFilter::getNotDefaultOptions()
839 std::vector<PropertyPtr> retval;
842 paramList defaultOptions = this->getDefaultParameters();
844 std::vector<StringPropertyPtr>::iterator stringDAIt;
845 for(stringDAIt = mStringOptions.begin(); stringDAIt != mStringOptions.end(); ++stringDAIt)
847 boost::unordered_map<std::string, StringParameter>::iterator stringIt;
848 for(stringIt = defaultOptions.strings.begin(); stringIt != defaultOptions.strings.end(); ++stringIt )
850 if(stringDAIt->get()->getDisplayName().toStdString() == stringIt->first)
852 if(stringDAIt->get()->getValue().toStdString() != stringIt->second.get())
853 retval.push_back(*stringDAIt);
858 std::vector<BoolPropertyPtr>::iterator boolDAIt;
859 for(boolDAIt = mBoolOptions.begin(); boolDAIt != mBoolOptions.end(); ++boolDAIt)
861 boost::unordered_map<std::string, BoolParameter>::iterator boolIt;
862 for(boolIt = defaultOptions.bools.begin(); boolIt != defaultOptions.bools.end(); ++boolIt )
864 if(boolDAIt->get()->getDisplayName().toStdString() == boolIt->first)
866 if(boolDAIt->get()->getValue() != boolIt->second.get())
867 retval.push_back(*boolDAIt);
872 std::vector<DoublePropertyPtr>::iterator doubleDAIt;
873 for(doubleDAIt = mDoubleOptions.begin(); doubleDAIt != mDoubleOptions.end(); ++doubleDAIt)
875 boost::unordered_map<std::string, NumericParameter>::iterator numericIt;
876 for(numericIt = defaultOptions.numerics.begin(); numericIt != defaultOptions.numerics.end(); ++numericIt )
878 if(doubleDAIt->get()->getDisplayName().toStdString() == numericIt->first)
880 if(!
similar(doubleDAIt->get()->getValue(), numericIt->second.get()))
881 retval.push_back(*doubleDAIt);
889 paramList TubeSegmentationFilter::getDefaultParameters()
892 paramList defaultOptions;
895 }
catch (SIPL::SIPLException& e){
896 std::string message =
"When creating default options, could not init parameters. \""+std::string(e.what())+
"\"";
899 return defaultOptions;
902 void TubeSegmentationFilter::printParameters(paramList parameters)
904 std::cout <<
"\n" << std::endl;
905 std::cout <<
"The following parameters are set: " << std::endl;
907 boost::unordered_map<std::string,StringParameter>::iterator itString;
908 for(itString = parameters.strings.begin(); itString != parameters.strings.end(); ++itString) {
909 std::cout << itString->first <<
" " << itString->second.get() << std::endl;
912 boost::unordered_map<std::string,BoolParameter>::iterator itBool;
913 for(itBool = parameters.bools.begin(); itBool != parameters.bools.end(); ++itBool) {
914 std::string value = itBool->second.get() ?
"true" :
"false";
915 std::cout << itBool->first <<
" " << value << std::endl;
918 boost::unordered_map<std::string,NumericParameter>::iterator itNumeric;
919 for(itNumeric = parameters.numerics.begin(); itNumeric != parameters.numerics.end(); ++itNumeric) {
920 std::cout << itNumeric->first <<
" " << itNumeric->second.get() << std::endl;
923 std::cout <<
"\n" << std::endl;
926 StringPropertyPtr TubeSegmentationFilter::makeStringOption(QDomElement root, std::string name, StringParameter parameter)
928 QString helptext =
qstring_cast(parameter.getDescription());
929 std::vector<std::string> possibilities = parameter.getPossibilities();
934 std::vector<std::string>::iterator it;
935 for(it = possibilities.begin(); it != possibilities.end(); ++it)
942 if(!possibilities.empty())
951 BoolPropertyPtr TubeSegmentationFilter::makeBoolOption(QDomElement root, std::string name, BoolParameter parameter)
953 QString helptext =
qstring_cast(parameter.getDescription());
954 bool value = parameter.get();
958 DoublePropertyPtr TubeSegmentationFilter::makeDoubleOption(QDomElement root, std::string name, NumericParameter parameter)
960 QString helptext =
qstring_cast(parameter.getDescription());
961 double value = parameter.get();
962 double min = parameter.getMin();
963 double max = parameter.getMax();
964 double step = parameter.getStep();
966 DoubleRange range(min, max, step);
QString qstring_cast(const T &val)
virtual QDomElement generatePresetFromCurrentlySetOptions(QString name)
get a xml element containing the currently set parameters
static BoolPropertyPtr initialize(const QString &uid, QString name, QString help, bool value, QDomNode root=QDomNode())
std::vector< SelectDataStringPropertyBasePtr > mInputTypes
void reportError(QString msg)
virtual QString getHelp() const
vtkSmartPointer< class vtkImageShiftScale > vtkImageShiftScalePtr
virtual QString getName() const
Transform3D createTransformScale(const Vector3D &scale_)
Transform3D Transform3D
Transform3D is a representation of an affine 3D transform.
virtual bool hasPresets()
virtual void createOptions()
boost::shared_ptr< class Image > ImagePtr
virtual PresetsPtr getPresets()
virtual void createOutputTypes()
QString timestampSecondsFormat()
vtkSmartPointer< class vtkPolyData > vtkPolyDataPtr
virtual void intitializeFromParentImage(ImagePtr parentImage)
bool similar(const DoubleBoundingBox3D &a, const DoubleBoundingBox3D &b, double tol)
std::vector< PropertyPtr > mOptionsAdapters
virtual ~TubeSegmentationFilter()
boost::shared_ptr< class Data > DataPtr
static QString findConfigFolder(QString pathRelativeToConfigRoot, QString alternativeAbsolutePath="")
boost::shared_ptr< class StringProperty > StringPropertyPtr
boost::shared_ptr< class TSFPresets > TSFPresetsPtr
boost::shared_ptr< class SelectDataStringPropertyBase > SelectDataStringPropertyBasePtr
boost::shared_ptr< class Property > PropertyPtr
PatientModelServicePtr patientService()
void reportWarning(QString msg)
void setVtkPolyData(const vtkPolyDataPtr &polyData)
virtual bool postProcess()
static QDomElement createPresetElement(QString name, std::map< QString, QString > ¶meters)
ImagePtr getCopiedInputImage(int index=0)
Transform3D createTransformTranslate(const Vector3D &translation)
static StringPropertySelectDataPtr New(PatientModelServicePtr patientModelService)
Represents one option of the string type. The data are stored within a xml document.
boost::shared_ptr< class Presets > PresetsPtr
static StringPropertyPtr initialize(const QString &uid, QString name, QString help, QString value, QStringList range, QDomNode root=QDomNode())
boost::shared_ptr< class DoubleProperty > DoublePropertyPtr
Eigen::Vector3d Vector3D
Vector3D is a representation of a point or vector in 3D.
virtual double getValue() const
get the data value.
vtkSmartPointer< class vtkImageImport > vtkImageImportPtr
TubeSegmentationFilter(ctkPluginContext *pluginContext)
std::vector< SelectDataStringPropertyBasePtr > mOutputTypes
static DoublePropertyPtr initialize(const QString &uid, QString name, QString help, double value, DoubleRange range, int decimals, QDomNode root=QDomNode())
virtual void requestSetPresetSlot(QString name)
try to set a specific preset
static StringPropertySelectMeshPtr New(PatientModelServicePtr patientModelService)
virtual bool postProcess()
static StringPropertySelectImagePtr New(PatientModelServicePtr patientModelService)
boost::shared_ptr< class BoolProperty > BoolPropertyPtr
boost::shared_ptr< class Mesh > MeshPtr
boost::shared_ptr< class StringPropertySelectMesh > StringPropertySelectMeshPtr
virtual void createInputTypes()
virtual QString getType() const
boost::shared_ptr< class StringPropertyBase > StringPropertyBasePtr