diff --git a/Modules/Bundles/org.mitk.gui.qt.segmentation/src/internal/QmitkCreatePolygonModelAction.cpp b/Modules/Bundles/org.mitk.gui.qt.segmentation/src/internal/QmitkCreatePolygonModelAction.cpp index e4e2f132b5..7cfbf7588f 100644 --- a/Modules/Bundles/org.mitk.gui.qt.segmentation/src/internal/QmitkCreatePolygonModelAction.cpp +++ b/Modules/Bundles/org.mitk.gui.qt.segmentation/src/internal/QmitkCreatePolygonModelAction.cpp @@ -1,160 +1,132 @@ #include "QmitkCreatePolygonModelAction.h" -#include "mitkShowSegmentationAsSmoothedSurface.h" -#include "mitkShowSegmentationAsSurface.h" -#include "mitkProgressBar.h" -#include "mitkStatusBar.h" +// MITK +#include +#include +#include +#include +// Blueberry #include #include +using namespace berry; +using namespace mitk; +using namespace std; + QmitkCreatePolygonModelAction::QmitkCreatePolygonModelAction() { } QmitkCreatePolygonModelAction::~QmitkCreatePolygonModelAction() { } -void QmitkCreatePolygonModelAction::Run(const std::vector& selectedNodes) +void QmitkCreatePolygonModelAction::Run(const vector &selectedNodes) { - NodeList selection = selectedNodes; + DataNode::Pointer selectedNode = selectedNodes[0]; + Image::Pointer image = dynamic_cast(selectedNode->GetData()); + + if (image.IsNull()) + return; - for ( NodeList::iterator iter = selection.begin(); iter != selection.end(); ++iter ) + try { - mitk::DataNode* node = *iter; - - if (node) + if (!m_IsSmoothed) { - mitk::Image::Pointer image = dynamic_cast( node->GetData() ); - if (image.IsNull()) return; - - try - { - if (!m_IsSmoothed) - { - mitk::ShowSegmentationAsSurface::Pointer surfaceFilter = mitk::ShowSegmentationAsSurface::New(); - - // attach observer to get notified about result - itk::SimpleMemberCommand::Pointer goodCommand = itk::SimpleMemberCommand::New(); - goodCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone); - surfaceFilter->AddObserver(mitk::ResultAvailable(), goodCommand); - itk::SimpleMemberCommand::Pointer badCommand = itk::SimpleMemberCommand::New(); - badCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone); - surfaceFilter->AddObserver(mitk::ProcessingError(), badCommand); - - mitk::DataNode::Pointer nodepointer = node; - surfaceFilter->SetPointerParameter("Input", image); - surfaceFilter->SetPointerParameter("Group node", nodepointer); - surfaceFilter->SetParameter("Show result", true ); - surfaceFilter->SetParameter("Sync visibility", false ); - surfaceFilter->SetDataStorage( *m_DataStorage ); - - /*if (this->m_IsSmoothed) - { - surfaceFilter->SetParameter("Smooth", true ); - //surfaceFilter->SetParameter("Apply median", true ); - surfaceFilter->SetParameter("Apply median", false ); // median makes the resulting surfaces look like lego models - surfaceFilter->SetParameter("Median kernel size", 3u ); - surfaceFilter->SetParameter("Gaussian SD", 2.5f ); - surfaceFilter->SetParameter("Decimate mesh", m_IsDecimated ); - surfaceFilter->SetParameter("Decimation rate", 0.8f ); - } - else - {*/ - surfaceFilter->SetParameter("Smooth", false ); - surfaceFilter->SetParameter("Apply median", false ); - surfaceFilter->SetParameter("Median kernel size", 3u ); - surfaceFilter->SetParameter("Gaussian SD", 1.5f ); - surfaceFilter->SetParameter("Decimate mesh", m_IsDecimated ); - surfaceFilter->SetParameter("Decimation rate", 0.8f ); - //} - - mitk::ProgressBar::GetInstance()->AddStepsToDo(10); - mitk::ProgressBar::GetInstance()->Progress(2); - mitk::StatusBar::GetInstance()->DisplayText("Surface creation started in background..."); - surfaceFilter->StartAlgorithm(); - } - else - { - mitk::ShowSegmentationAsSmoothedSurface::Pointer filter = mitk::ShowSegmentationAsSmoothedSurface::New(); - - itk::SimpleMemberCommand::Pointer goodCommand = itk::SimpleMemberCommand::New(); - goodCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone); - filter->AddObserver(mitk::ResultAvailable(), goodCommand); - - itk::SimpleMemberCommand::Pointer badCommand = itk::SimpleMemberCommand::New(); - badCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone); - filter->AddObserver(mitk::ProcessingError(), badCommand); - - mitk::DataNode::Pointer nodepointer = node; - filter->SetPointerParameter("Input", image); - filter->SetPointerParameter("Group node", nodepointer); - filter->SetDataStorage(*m_DataStorage); - - berry::IPreferencesService::Pointer prefService = berry::Platform::GetServiceRegistry().GetServiceById(berry::IPreferencesService::ID); - berry::IPreferences::Pointer segPref = prefService->GetSystemPreferences()->Node("/org.mitk.views.segmentation"); - - bool smoothingHint = segPref->GetBool("smoothing hint", true); - float smoothing = (float)segPref->GetDouble("smoothing value", 1.0); - float decimation = (float)segPref->GetDouble("decimation rate", 0.5); - - if (smoothingHint) - { - smoothing = 0.0; - mitk::Vector3D spacing = image->GetGeometry()->GetSpacing(); - - for (mitk::Vector3D::Iterator iter = spacing.Begin(); iter != spacing.End(); ++iter) - smoothing = std::max(smoothing, *iter); - - filter->SetParameter("Smoothing", smoothing); - } - else - { - filter->SetParameter("Smoothing", smoothing); - } - - filter->SetParameter("Decimation", decimation); - - mitk::ProgressBar::GetInstance()->AddStepsToDo(8); - mitk::StatusBar::GetInstance()->DisplayText("Smoothed surface creation started in background..."); - - filter->StartAlgorithm(); - } - } - catch(...) - { - MITK_ERROR << "surface creation filter had an error"; - } + ShowSegmentationAsSurface::Pointer surfaceFilter = ShowSegmentationAsSurface::New(); + + itk::SimpleMemberCommand::Pointer successCommand = itk::SimpleMemberCommand::New(); + successCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone); + surfaceFilter->AddObserver(ResultAvailable(), successCommand); + + itk::SimpleMemberCommand::Pointer errorCommand = itk::SimpleMemberCommand::New(); + errorCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone); + surfaceFilter->AddObserver(ProcessingError(), errorCommand); + + surfaceFilter->SetDataStorage(*m_DataStorage); + surfaceFilter->SetPointerParameter("Input", image); + surfaceFilter->SetPointerParameter("Group node", selectedNode); + surfaceFilter->SetParameter("Show result", true); + surfaceFilter->SetParameter("Sync visibility", false); + surfaceFilter->SetParameter("Smooth", false); + surfaceFilter->SetParameter("Apply median", false); + surfaceFilter->SetParameter("Median kernel size", 3u); + surfaceFilter->SetParameter("Gaussian SD", 1.5f); + surfaceFilter->SetParameter("Decimate mesh", m_IsDecimated); + surfaceFilter->SetParameter("Decimation rate", 0.8f); + + StatusBar::GetInstance()->DisplayText("Surface creation started in background..."); + + surfaceFilter->StartAlgorithm(); } else { - MITK_INFO << " a NULL node selected"; + ShowSegmentationAsSmoothedSurface::Pointer surfaceFilter = ShowSegmentationAsSmoothedSurface::New(); + + itk::SimpleMemberCommand::Pointer successCommand = itk::SimpleMemberCommand::New(); + successCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone); + surfaceFilter->AddObserver(mitk::ResultAvailable(), successCommand); + + itk::SimpleMemberCommand::Pointer errorCommand = itk::SimpleMemberCommand::New(); + errorCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone); + surfaceFilter->AddObserver(mitk::ProcessingError(), errorCommand); + + surfaceFilter->SetDataStorage(*m_DataStorage); + surfaceFilter->SetPointerParameter("Input", image); + surfaceFilter->SetPointerParameter("Group node", selectedNode); + + IPreferencesService::Pointer prefService = Platform::GetServiceRegistry().GetServiceById(IPreferencesService::ID); + IPreferences::Pointer segPref = prefService->GetSystemPreferences()->Node("/org.mitk.views.segmentation"); + + bool smoothingHint = segPref->GetBool("smoothing hint", true); + float smoothing = (float)segPref->GetDouble("smoothing value", 1.0); + float decimation = (float)segPref->GetDouble("decimation rate", 0.5); + + if (smoothingHint) + { + smoothing = 0.0; + Vector3D spacing = image->GetGeometry()->GetSpacing(); + + for (Vector3D::Iterator iter = spacing.Begin(); iter != spacing.End(); ++iter) + smoothing = max(smoothing, *iter); + } + + surfaceFilter->SetParameter("Smoothing", smoothing); + surfaceFilter->SetParameter("Decimation", decimation); + + ProgressBar::GetInstance()->AddStepsToDo(8); + StatusBar::GetInstance()->DisplayText("Smoothed surface creation started in background..."); + + surfaceFilter->StartAlgorithm(); } } + catch(...) + { + MITK_ERROR << "Surface creation failed!"; + } } void QmitkCreatePolygonModelAction::OnSurfaceCalculationDone() { - mitk::ProgressBar::GetInstance()->Progress(8); + StatusBar::GetInstance()->Clear(); } -void QmitkCreatePolygonModelAction::SetSmoothed(bool smoothed) +void QmitkCreatePolygonModelAction::SetDataStorage(DataStorage *dataStorage) { - this->m_IsSmoothed = smoothed; + m_DataStorage = dataStorage; } -void QmitkCreatePolygonModelAction::SetDecimated(bool decimated) +void QmitkCreatePolygonModelAction::SetSmoothed(bool smoothed) { - this->m_IsDecimated = decimated; + m_IsSmoothed = smoothed; } -void QmitkCreatePolygonModelAction::SetDataStorage(mitk::DataStorage* dataStorage) +void QmitkCreatePolygonModelAction::SetDecimated(bool decimated) { - this->m_DataStorage = dataStorage; + m_IsDecimated = decimated; } -void QmitkCreatePolygonModelAction::SetFunctionality(berry::QtViewPart *functionality) +void QmitkCreatePolygonModelAction::SetFunctionality(QtViewPart *) { - //not needed } diff --git a/Modules/Bundles/org.mitk.gui.qt.segmentation/src/internal/QmitkCreatePolygonModelAction.h b/Modules/Bundles/org.mitk.gui.qt.segmentation/src/internal/QmitkCreatePolygonModelAction.h index d345998db7..9b8272a9e2 100644 --- a/Modules/Bundles/org.mitk.gui.qt.segmentation/src/internal/QmitkCreatePolygonModelAction.h +++ b/Modules/Bundles/org.mitk.gui.qt.segmentation/src/internal/QmitkCreatePolygonModelAction.h @@ -1,45 +1,40 @@ -#ifndef QMITK_CREATEPOLYGONMODELACTION_H -#define QMITK_CREATEPOLYGONMODELACTION_H +#ifndef QMITKCREATEPOLYGONMODELACTION_H +#define QMITKCREATEPOLYGONMODELACTION_H -#include "berryQtViewPart.h" -#include "mitkIContextMenuAction.h" +#include -#include "org_mitk_gui_qt_segmentation_Export.h" +// Parent classes +#include +#include -#include "mitkDataNode.h" +// Data members +#include -class MITK_QT_SEGMENTATION QmitkCreatePolygonModelAction: public QObject, public mitk::IContextMenuAction +class MITK_QT_SEGMENTATION QmitkCreatePolygonModelAction : public QObject, public mitk::IContextMenuAction { Q_OBJECT Q_INTERFACES(mitk::IContextMenuAction) public: QmitkCreatePolygonModelAction(); - QmitkCreatePolygonModelAction(const QmitkCreatePolygonModelAction& other) - { - Q_UNUSED(other) - throw std::runtime_error("Copy constructor not implemented"); - } - virtual ~QmitkCreatePolygonModelAction(); - - //interface methods - void Run( const std::vector& selectedNodes ); - void SetDataStorage(mitk::DataStorage* dataStorage); + ~QmitkCreatePolygonModelAction(); + + // IContextMenuAction + void Run(const std::vector &selectedNodes); + void SetDataStorage(mitk::DataStorage *dataStorage); void SetSmoothed(bool smoothed); void SetDecimated(bool decimated); - void SetFunctionality(berry::QtViewPart* functionality); + void SetFunctionality(berry::QtViewPart *functionality); - // for receiving messages void OnSurfaceCalculationDone(); -protected: - - typedef std::vector NodeList; +private: + QmitkCreatePolygonModelAction(const QmitkCreatePolygonModelAction &); + QmitkCreatePolygonModelAction & operator=(const QmitkCreatePolygonModelAction &); mitk::DataStorage::Pointer m_DataStorage; - bool m_IsSmoothed; bool m_IsDecimated; - }; -#endif // QMITK_CREATEPOLYGONMODELACTION_H + +#endif diff --git a/Modules/Bundles/org.mitk.gui.qt.segmentation/src/internal/QmitkThresholdAction.cpp b/Modules/Bundles/org.mitk.gui.qt.segmentation/src/internal/QmitkThresholdAction.cpp index 1dfbe7e3c4..d36f253df0 100644 --- a/Modules/Bundles/org.mitk.gui.qt.segmentation/src/internal/QmitkThresholdAction.cpp +++ b/Modules/Bundles/org.mitk.gui.qt.segmentation/src/internal/QmitkThresholdAction.cpp @@ -1,99 +1,99 @@ #include "QmitkThresholdAction.h" // MITK #include #include #include // Qt #include #include -using namespace itk; +using namespace berry; using namespace mitk; using namespace std; QmitkThresholdAction::QmitkThresholdAction() : m_ThresholdingDialog(NULL) { } QmitkThresholdAction::~QmitkThresholdAction() { } void QmitkThresholdAction::Run(const vector &selectedNodes) { - m_ThresholdingToolManager = mitk::ToolManager::New(m_DataStorage); + m_ThresholdingToolManager = ToolManager::New(m_DataStorage); m_ThresholdingToolManager->RegisterClient(); - m_ThresholdingToolManager->ActiveToolChanged += MessageDelegate(this, &QmitkThresholdAction::OnThresholdingToolManagerToolModified); + m_ThresholdingToolManager->ActiveToolChanged += mitk::MessageDelegate(this, &QmitkThresholdAction::OnThresholdingToolManagerToolModified); m_ThresholdingDialog = new QDialog; connect(m_ThresholdingDialog, SIGNAL(finished(int)), this, SLOT(ThresholdingDone(int))); QVBoxLayout *layout = new QVBoxLayout; layout->setContentsMargins(0, 0, 0, 0); - mitk::Tool *binaryThresholdTool = m_ThresholdingToolManager->GetToolById(m_ThresholdingToolManager->GetToolIdByToolType()); + Tool *binaryThresholdTool = m_ThresholdingToolManager->GetToolById(m_ThresholdingToolManager->GetToolIdByToolType()); if (binaryThresholdTool != NULL) { QmitkToolGUI *gui = dynamic_cast(binaryThresholdTool->GetGUI("Qmitk", "GUI").GetPointer()); if (gui != NULL) { gui->SetTool(binaryThresholdTool); gui->setParent(m_ThresholdingDialog); layout->addWidget(gui); m_ThresholdingDialog->setLayout(layout); m_ThresholdingDialog->setFixedSize(300, 80); m_ThresholdingDialog->open(); } m_ThresholdingToolManager->SetReferenceData(selectedNodes[0]); m_ThresholdingToolManager->ActivateTool(m_ThresholdingToolManager->GetToolIdByToolType()); } } void QmitkThresholdAction::ThresholdingDone(int result) { if (result == QDialog::Rejected) m_ThresholdingToolManager->ActivateTool(-1); m_ThresholdingDialog->deleteLater(); m_ThresholdingDialog = NULL; m_ThresholdingToolManager->SetReferenceData(NULL); m_ThresholdingToolManager->SetWorkingData(NULL); RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkThresholdAction::OnThresholdingToolManagerToolModified() { if (m_ThresholdingToolManager.IsNotNull()) if (m_ThresholdingToolManager->GetActiveToolID() < 0) if (m_ThresholdingDialog != NULL) m_ThresholdingDialog->accept(); } -void QmitkThresholdAction::SetDataStorage(mitk::DataStorage *dataStorage) +void QmitkThresholdAction::SetDataStorage(DataStorage *dataStorage) { - this->m_DataStorage = dataStorage; + m_DataStorage = dataStorage; } void QmitkThresholdAction::SetSmoothed(bool) { } void QmitkThresholdAction::SetDecimated(bool) { } -void QmitkThresholdAction::SetFunctionality(berry::QtViewPart *functionality) +void QmitkThresholdAction::SetFunctionality(QtViewPart *functionality) { } diff --git a/Modules/MitkExt/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp b/Modules/MitkExt/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp index 58321d1baa..18fc621957 100644 --- a/Modules/MitkExt/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp +++ b/Modules/MitkExt/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp @@ -1,509 +1,507 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mitkShowSegmentationAsSmoothedSurface.h" #include "mitkImageToItk.h" #include "itkIntelligentBinaryClosingFilter.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace mitk; using namespace std; ShowSegmentationAsSmoothedSurface::ShowSegmentationAsSmoothedSurface() { } ShowSegmentationAsSmoothedSurface::~ShowSegmentationAsSmoothedSurface() { } void ShowSegmentationAsSmoothedSurface::Initialize(const NonBlockingAlgorithm *other) { Superclass::Initialize(other); bool syncVisibility = false; if (other != NULL) other->GetParameter("Sync visibility", syncVisibility); SetParameter("Sync visibility", syncVisibility); SetParameter("Wireframe", false); // The Smoothing value is used as variance for a Gauß filter. // A reasonable default value equals the image spacing in mm. SetParameter("Smoothing", 1.0f); // Valid range for decimation value is [0, 1). High values // increase decimation, especially when very close to 1. // A value of 0 disables decimation. SetParameter("Decimation", 0.5f); } bool ShowSegmentationAsSmoothedSurface::ReadyToRun() { try { mitk::Image::Pointer image; GetPointerParameter("Input", image); return image.IsNotNull() && GetGroupNode(); } catch (const invalid_argument &) { return false; } } bool ShowSegmentationAsSmoothedSurface::ThreadedUpdateFunction() { Image::Pointer image; GetPointerParameter("Input", image); float smoothing; GetParameter("Smoothing", smoothing); float decimation; GetParameter("Decimation", decimation); MITK_INFO << "CREATING SMOOTHED POLYGON MODEL" << endl; MITK_INFO << " Smoothing = " << smoothing << endl; MITK_INFO << " Decimation = " << decimation << endl; Geometry3D::Pointer geometry = image->GetGeometry(); // Make ITK image out of MITK image typedef itk::Image CharImageType; typedef itk::Image ShortImageType; typedef itk::Image FloatImageType; ImageToItk::Pointer imageToItkFilter = ImageToItk::New(); try { imageToItkFilter->SetInput(image); } catch (const itk::ExceptionObject &e) { // Most probably the input image type is wrong. Binary images are expected to be // >unsigned< char images. MITK_ERROR << e.GetDescription() << endl; return false; } imageToItkFilter->Update(); CharImageType::Pointer itkImage = imageToItkFilter->GetOutput(); // Get bounding box and relabel MITK_INFO << "Extracting VOI..." << endl; int imageLabel = 1; bool roiFound = false; CharImageType::IndexType minIndex; minIndex.Fill(numeric_limits::max()); CharImageType::IndexType maxIndex; maxIndex.Fill(numeric_limits::min()); itk::ImageRegionIteratorWithIndex iter(itkImage, itkImage->GetLargestPossibleRegion()); for (iter.GoToBegin(); !iter.IsAtEnd(); ++iter) { if (iter.Get() == imageLabel) { roiFound = true; iter.Set(1); CharImageType::IndexType currentIndex = iter.GetIndex(); for (unsigned int dim = 0; dim < 3; ++dim) { minIndex[dim] = min(currentIndex[dim], minIndex[dim]); maxIndex[dim] = max(currentIndex[dim], maxIndex[dim]); } } else { iter.Set(0); } } if (!roiFound) { - ProgressBar::GetInstance()->Progress(10); + ProgressBar::GetInstance()->Progress(8); MITK_ERROR << "Didn't found segmentation labeled with " << imageLabel << "!" << endl; return false; } ProgressBar::GetInstance()->Progress(1); // Extract and pad bounding box typedef itk::RegionOfInterestImageFilter ROIFilterType; ROIFilterType::Pointer roiFilter = ROIFilterType::New(); CharImageType::RegionType region; CharImageType::SizeType size; for (unsigned int dim = 0; dim < 3; ++dim) { size[dim] = maxIndex[dim] - minIndex[dim] + 1; } region.SetIndex(minIndex); region.SetSize(size); roiFilter->SetInput(itkImage); roiFilter->SetRegionOfInterest(region); roiFilter->ReleaseDataFlagOn(); roiFilter->ReleaseDataBeforeUpdateFlagOn(); typedef itk::ConstantPadImageFilter PadFilterType; PadFilterType::Pointer padFilter = PadFilterType::New(); const PadFilterType::SizeValueType pad[3] = { 10, 10, 10 }; padFilter->SetInput(roiFilter->GetOutput()); padFilter->SetConstant(0); padFilter->SetPadLowerBound(pad); padFilter->SetPadUpperBound(pad); padFilter->ReleaseDataFlagOn(); padFilter->ReleaseDataBeforeUpdateFlagOn(); padFilter->Update(); CharImageType::Pointer roiImage = padFilter->GetOutput(); roiImage->DisconnectPipeline(); roiFilter = 0; padFilter = 0; // Correct origin of real geometry (changed by cropping and padding) typedef AffineGeometryFrame3D::TransformType TransformType; TransformType::Pointer transform = TransformType::New(); TransformType::OutputVectorType translation; for (unsigned int dim = 0; dim < 3; ++dim) translation[dim] = (int)minIndex[dim] - (int)pad[dim]; transform->SetIdentity(); transform->Translate(translation); geometry->Compose(transform, true); ProgressBar::GetInstance()->Progress(1); // Median MITK_INFO << "Median..." << endl; typedef itk::BinaryMedianImageFilter MedianFilterType; MedianFilterType::Pointer medianFilter = MedianFilterType::New(); CharImageType::SizeType radius = { 1, 1, 1 }; medianFilter->SetRadius(radius); medianFilter->SetBackgroundValue(0); medianFilter->SetForegroundValue(1); medianFilter->SetInput(roiImage); medianFilter->ReleaseDataFlagOn(); medianFilter->ReleaseDataBeforeUpdateFlagOn(); medianFilter->Update(); ProgressBar::GetInstance()->Progress(1); // Intelligent closing MITK_INFO << "Intelligent closing..." << endl; unsigned int surfaceRatio = 70; typedef itk::IntelligentBinaryClosingFilter ClosingFilterType; ClosingFilterType::Pointer closingFilter = ClosingFilterType::New(); closingFilter->SetInput(medianFilter->GetOutput()); closingFilter->ReleaseDataFlagOn(); closingFilter->ReleaseDataBeforeUpdateFlagOn(); closingFilter->SetSurfaceRatio(surfaceRatio); closingFilter->Update(); ShortImageType::Pointer closedImage = closingFilter->GetOutput(); closedImage->DisconnectPipeline(); roiImage = 0; medianFilter = 0; closingFilter = 0; ProgressBar::GetInstance()->Progress(1); // Gaussian blur MITK_INFO << "Gauss..." << endl; typedef itk::BinaryThresholdImageFilter BinaryThresholdToFloatFilterType; BinaryThresholdToFloatFilterType::Pointer binThresToFloatFilter = BinaryThresholdToFloatFilterType::New(); binThresToFloatFilter->SetInput(closedImage); binThresToFloatFilter->SetLowerThreshold(1); binThresToFloatFilter->SetUpperThreshold(1); binThresToFloatFilter->SetInsideValue(100); binThresToFloatFilter->SetOutsideValue(0); binThresToFloatFilter->ReleaseDataFlagOn(); binThresToFloatFilter->ReleaseDataBeforeUpdateFlagOn(); typedef itk::DiscreteGaussianImageFilter GaussianFilterType; // From the following line on, IntelliSense (VS 2008) is broken. Any idea how to fix it? GaussianFilterType::Pointer gaussFilter = GaussianFilterType::New(); gaussFilter->SetInput(binThresToFloatFilter->GetOutput()); gaussFilter->SetUseImageSpacing(true); gaussFilter->SetVariance(smoothing); gaussFilter->ReleaseDataFlagOn(); gaussFilter->ReleaseDataBeforeUpdateFlagOn(); typedef itk::BinaryThresholdImageFilter BinaryThresholdFromFloatFilterType; BinaryThresholdFromFloatFilterType::Pointer binThresFromFloatFilter = BinaryThresholdFromFloatFilterType::New(); binThresFromFloatFilter->SetInput(gaussFilter->GetOutput()); binThresFromFloatFilter->SetLowerThreshold(50); binThresFromFloatFilter->SetUpperThreshold(255); binThresFromFloatFilter->SetInsideValue(1); binThresFromFloatFilter->SetOutsideValue(0); binThresFromFloatFilter->ReleaseDataFlagOn(); binThresFromFloatFilter->ReleaseDataBeforeUpdateFlagOn(); binThresFromFloatFilter->Update(); CharImageType::Pointer blurredImage = binThresFromFloatFilter->GetOutput(); blurredImage->DisconnectPipeline(); closedImage = 0; binThresToFloatFilter = 0; gaussFilter = 0; ProgressBar::GetInstance()->Progress(1); // Fill holes MITK_INFO << "Filling cavities..." << endl; typedef itk::ConnectedThresholdImageFilter ConnectedThresholdFilterType; ConnectedThresholdFilterType::Pointer connectedThresFilter = ConnectedThresholdFilterType::New(); CharImageType::IndexType corner; corner[0] = 0; corner[1] = 0; corner[2] = 0; connectedThresFilter->SetInput(blurredImage); connectedThresFilter->SetSeed(corner); connectedThresFilter->SetLower(0); connectedThresFilter->SetUpper(0); connectedThresFilter->SetReplaceValue(2); connectedThresFilter->ReleaseDataFlagOn(); connectedThresFilter->ReleaseDataBeforeUpdateFlagOn(); typedef itk::BinaryThresholdImageFilter BinaryThresholdFilterType; BinaryThresholdFilterType::Pointer binThresFilter = BinaryThresholdFilterType::New(); binThresFilter->SetInput(connectedThresFilter->GetOutput()); binThresFilter->SetLowerThreshold(0); binThresFilter->SetUpperThreshold(0); binThresFilter->SetInsideValue(50); binThresFilter->SetOutsideValue(0); binThresFilter->ReleaseDataFlagOn(); binThresFilter->ReleaseDataBeforeUpdateFlagOn(); typedef itk::AddImageFilter AddFilterType; AddFilterType::Pointer addFilter = AddFilterType::New(); addFilter->SetInput1(blurredImage); addFilter->SetInput2(binThresFilter->GetOutput()); addFilter->ReleaseDataFlagOn(); addFilter->ReleaseDataBeforeUpdateFlagOn(); addFilter->Update(); ProgressBar::GetInstance()->Progress(1); // Surface extraction MITK_INFO << "Surface extraction..." << endl; Image::Pointer filteredImage = Image::New(); CastToMitkImage(addFilter->GetOutput(), filteredImage); filteredImage->SetGeometry(geometry); ImageToSurfaceFilter::Pointer imageToSurfaceFilter = ImageToSurfaceFilter::New(); imageToSurfaceFilter->SetInput(filteredImage); imageToSurfaceFilter->SetThreshold(50); imageToSurfaceFilter->SmoothOn(); imageToSurfaceFilter->SetDecimate(ImageToSurfaceFilter::NoDecimation); m_Surface = imageToSurfaceFilter->GetOutput(); ProgressBar::GetInstance()->Progress(1); // Mesh decimation if (decimation > 0.0f && decimation < 1.0f) { MITK_INFO << "Quadric mesh decimation..." << endl; vtkQuadricDecimation *quadricDecimation = vtkQuadricDecimation::New(); quadricDecimation->SetInput(m_Surface->GetVtkPolyData()); quadricDecimation->SetTargetReduction(decimation); quadricDecimation->AttributeErrorMetricOn(); quadricDecimation->Update(); vtkCleanPolyData* cleaner = vtkCleanPolyData::New(); cleaner->SetInput(quadricDecimation->GetOutput()); cleaner->PieceInvariantOn(); cleaner->ConvertLinesToPointsOn(); cleaner->ConvertStripsToPolysOn(); cleaner->PointMergingOn(); cleaner->Update(); m_Surface->SetVtkPolyData(cleaner->GetOutput()); } ProgressBar::GetInstance()->Progress(1); // Compute Normals vtkPolyDataNormals* computeNormals = vtkPolyDataNormals::New(); computeNormals->SetInput(m_Surface->GetVtkPolyData()); computeNormals->SetFeatureAngle(360.0f); computeNormals->FlipNormalsOff(); computeNormals->Update(); m_Surface->SetVtkPolyData(computeNormals->GetOutput()); return true; } void ShowSegmentationAsSmoothedSurface::ThreadedUpdateSuccessful() { DataNode::Pointer node = LookForPointerTargetBelowGroupNode("Surface representation"); bool addToTree = node.IsNull(); if (addToTree) { node = DataNode::New(); bool wireframe = false; GetParameter("Wireframe", wireframe); if (wireframe) { VtkRepresentationProperty *representation = dynamic_cast( node->GetProperty("material.representation")); if (representation != NULL) representation->SetRepresentationToWireframe(); } node->SetProperty("opacity", FloatProperty::New(0.3)); node->SetProperty("line width", IntProperty::New(1)); node->SetProperty("scalar visibility", BoolProperty::New(false)); UIDGenerator uidGenerator("Surface_"); node->SetProperty("FILENAME", StringProperty::New(uidGenerator.GetUID() + ".vtk")); std::string groupNodeName = "surface"; DataNode *groupNode = GetGroupNode(); if (groupNode != NULL) groupNode->GetName(groupNodeName); node->SetProperty("name", StringProperty::New(groupNodeName)); } node->SetData(m_Surface); if (addToTree) { DataNode* groupNode = GetGroupNode(); if (groupNode != NULL) { groupNode->SetProperty("Surface representation", SmartPointerProperty::New(node)); BaseProperty *colorProperty = groupNode->GetProperty("color"); if (colorProperty != NULL) node->ReplaceProperty("color", colorProperty); else node->SetProperty("color", ColorProperty::New(1.0f, 1.0f, 0.0f)); bool showResult = true; GetParameter("Show result", showResult); bool syncVisibility = false; GetParameter("Sync visibility", syncVisibility); Image::Pointer image; GetPointerParameter("Input", image); BaseProperty *organTypeProperty = image->GetProperty("organ type"); if (organTypeProperty != NULL) m_Surface->SetProperty("organ type", organTypeProperty); BaseProperty *visibleProperty = groupNode->GetProperty("visible"); if (visibleProperty != NULL && syncVisibility) node->ReplaceProperty("visible", visibleProperty); else node->SetProperty("visible", BoolProperty::New(showResult)); } InsertBelowGroupNode(node); } - StatusBar::GetInstance()->Clear(); - Superclass::ThreadedUpdateSuccessful(); }