diff --git a/Plugins/org.mitk.gui.qt.activelearning/files.cmake b/Plugins/org.mitk.gui.qt.activelearning/files.cmake index 84cfc4ede5..c66ec73a32 100644 --- a/Plugins/org.mitk.gui.qt.activelearning/files.cmake +++ b/Plugins/org.mitk.gui.qt.activelearning/files.cmake @@ -1,43 +1,44 @@ set(SRC_CPP_FILES ) set(INTERNAL_CPP_FILES org_mitk_gui_qt_activelearning_Activator.cpp QmitkActiveLearning.cpp + QmitkActiveLearningLogger.cpp ) set(UI_FILES src/internal/QmitkActiveLearningControls.ui ) set(MOC_H_FILES src/internal/org_mitk_gui_qt_activelearning_Activator.h src/internal/QmitkActiveLearning.h ) # list of resource files which can be used by the plug-in # system without loading the plug-ins shared library, # for example the icon used in the menu and tabs for the # plug-in views in the workbench set(CACHED_RESOURCE_FILES resources/icon.xpm resources/erase_icon_100.png resources/paint_icon_200.png plugin.xml ) # list of Qt .qrc files which contain additional resources # specific to this plugin set(QRC_FILES ) set(CPP_FILES ) foreach(file ${SRC_CPP_FILES}) set(CPP_FILES ${CPP_FILES} src/${file}) endforeach(file ${SRC_CPP_FILES}) foreach(file ${INTERNAL_CPP_FILES}) set(CPP_FILES ${CPP_FILES} src/internal/${file}) endforeach(file ${INTERNAL_CPP_FILES}) diff --git a/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.cpp b/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.cpp index d0b1d8b660..528191d07b 100644 --- a/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.cpp +++ b/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.cpp @@ -1,1392 +1,1407 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ // Blueberry #include #include // Qt #include #include #include #include +#include // Qmitk #include "QmitkActiveLearning.h" // MITK #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // ITK/VTK #include #include #include #include #include #include #include #include #include #include #include typedef ActiveLearning::FeaturePixelType FeaturePixelType; typedef ActiveLearning::AnnotationPixelType AnnotationPixelType; typedef ActiveLearning::LabelPixelType LabelPixelType; typedef ActiveLearning::FeatureMatrixType FeatureMatrixType; typedef ActiveLearning::LabelVectorType LabelVectorType; // Returns true if list has at least one entry and all entries are valid mitk::Images, otherwise false static bool SelectionAllImages(const QList& nodes) { if (nodes.empty()) { return false; } for (const auto& node : nodes) { if(!(node.IsNotNull() && dynamic_cast(node->GetData()) != nullptr)) return false; } return true; } // QColor to mitk::Color static mitk::Color QColorToMitkColor(const QColor& qcolor) { mitk::Color color; color.SetRed((float)qcolor.red() / 255); color.SetGreen((float)qcolor.green() / 255); color.SetBlue((float)qcolor.blue() / 255); return color; } // For debugging static void PrintAllLabels(mitk::LabelSetImage* image) { for (auto it=image->GetActiveLabelSet()->IteratorBegin(); it!=image->GetActiveLabelSet()->IteratorConstEnd(); ++it) { MITK_INFO << "Key: " << it->first << " - Name: " << it->second->GetName() << " - Value: " << it->second->GetValue() << " - Color: " << it->second->GetColor(); } } // Make values of labels a consistent range static void FillLabelValues(mitk::LabelSetImage* image) { int value(0); for (auto it=image->GetActiveLabelSet()->IteratorBegin(); it!=image->GetActiveLabelSet()->IteratorConstEnd(); ++it) { it->second->SetValue(value); value++; } image->GetActiveLabelSet()->SetActiveLabel(0); } // Fill image with zeros static void FillWithZeros(mitk::Image* image) { unsigned int size = image->GetPixelType().GetSize(); for (unsigned int i=0; iGetDimension(); i++) { size *= image->GetDimension(i); } for (unsigned int t=0; tGetTimeSteps(); t++) { mitk::ImageWriteAccessor accessor(image, image->GetVolumeData(0)); memset(accessor.GetData(), 0, size); } } template static Eigen::Matrix Transform(const std::vector images) { // Find size for output matrix [number of voxels, number of feature images] unsigned int size = images[0]->GetDimension(0); for (unsigned int i=1; i<3; ++i) { size *= images[0]->GetDimension(i); } Eigen::Matrix outputMatrix(size, images.size()); for (unsigned int i=0; i::Pointer imageItk; mitk::CastToItkImage(images[i], imageItk); outputMatrix.col(i) = Eigen::Matrix::Map(imageItk->GetBufferPointer(), size); } return outputMatrix; } template static mitk::Image::Pointer Transform(const Eigen::Matrix &inputMatrix, const mitk::Image::Pointer referenceImage) { typename itk::Image::Pointer imageItk; auto outputImage = mitk::Image::New(); outputImage->Initialize(mitk::MakeScalarPixelType(), *(referenceImage->GetTimeGeometry()->Clone())); mitk::CastToItkImage(outputImage, imageItk); auto it = itk::ImageRegionIterator>(imageItk, imageItk->GetLargestPossibleRegion()); int i = 0; while (!it.IsAtEnd()) { it.Set(inputMatrix(i, 0)); ++it; ++i; } mitk::GrabItkImageMemory(imageItk, outputImage); return outputImage; } template static std::vector Transform(const Eigen::Matrix &inputMatrix, const mitk::Image::Pointer referenceImage) { std::vector resultVector; for (int j=0; j::Pointer imageItk; auto outputImage = mitk::Image::New(); outputImage->Initialize(mitk::MakeScalarPixelType(), *(referenceImage->GetTimeGeometry()->Clone())); mitk::CastToItkImage(outputImage, imageItk); auto it = itk::ImageRegionIterator>(imageItk, imageItk->GetLargestPossibleRegion()); int i = 0; while (!it.IsAtEnd()) { it.Set(static_cast(inputMatrix(i, j))); ++it; ++i; } mitk::GrabItkImageMemory(imageItk, outputImage); resultVector.push_back(outputImage); } return resultVector; } template static void PrintMatrix(const Eigen::Matrix dataMatrix, int maxRows = 0) { if (maxRows == 0 || maxRows > dataMatrix.rows()) maxRows = dataMatrix.rows(); MITK_INFO << "---------------------"; for (int i=0; i static void PrintMatrix(const Eigen::Matrix dataMatrix, const Eigen::Matrix labelMatrix, int maxRows = 0) { if (labelMatrix.rows() < dataMatrix.rows()) return; if (maxRows == 0 || maxRows > dataMatrix.rows()) maxRows = dataMatrix.rows(); MITK_INFO << "---------------------"; for (int i=0; i static void GaussianSmoothing(const itk::Image* inputImage, const double sigma, mitk::Image::Pointer outputImage) { auto spacing = inputImage->GetSpacing(); float mean_spacing = (spacing[0] + spacing[1] + spacing[2]) / 3.; typedef itk::Image ImageType; typedef itk::Image FeatureImageType; auto filter = itk::DiscreteGaussianImageFilter::New(); filter->SetInput(inputImage); filter->SetVariance(sigma*sigma*mean_spacing*mean_spacing); filter->Update(); mitk::GrabItkImageMemory(filter->GetOutput(), outputImage); } template static void GaussianGradientMagnitude(const itk::Image* inputImage, const double sigma, mitk::Image::Pointer outputImage) { auto spacing = inputImage->GetSpacing(); float mean_spacing = (spacing[0] + spacing[1] + spacing[2]) / 3.; typedef itk::Image ImageType; typedef itk::Image FeatureImageType; auto filter = itk::GradientMagnitudeRecursiveGaussianImageFilter::New(); filter->SetInput(inputImage); filter->SetSigma(sigma*mean_spacing); filter->Update(); mitk::GrabItkImageMemory(filter->GetOutput(), outputImage); } template static void LaplacianOfGaussian(const itk::Image* inputImage, const double sigma, mitk::Image::Pointer outputImage) { auto spacing = inputImage->GetSpacing(); float mean_spacing = (spacing[0] + spacing[1] + spacing[2]) / 3.; typedef itk::Image ImageType; typedef itk::Image FeatureImageType; auto filter = itk::LaplacianRecursiveGaussianImageFilter::New(); filter->SetInput(inputImage); filter->SetSigma(sigma*mean_spacing); filter->Update(); mitk::GrabItkImageMemory(filter->GetOutput(), outputImage); } template static void StructureTensorEigenvalues(const itk::Image* inputImage, float sigma, std::vector outputImages) { // typedef itk::Image ImageType; // auto filter = itk::StructureTensorEigenvalueImageFilter::New(); // filter->SetInput(inputImage); // filter->SetInnerScale(sigma); // filter->SetOuterScale(sigma); // filter->Update(); // for (unsigned int i=0; iGetNumberOfOutputs(); i++) // { // mitk::GrabItkImageMemory(filter->GetOutput(i), outputImages[i]); // } auto spacing = inputImage->GetSpacing(); float mean_spacing = (spacing[0] + spacing[1] + spacing[2]) / 3.; typedef itk::Image ImageType; typedef itk::Image, imageDimension> TensorImageType; typename itk::StructureTensorImageFilter::Pointer filter = itk::StructureTensorImageFilter::New(); filter->SetInput(inputImage); filter->SetNoiseScale(sigma*mean_spacing); filter->SetFeatureScale(sigma*mean_spacing); filter->Update(); std::vector eigenValueImages; std::vector> eigenValueImageIterators; for (unsigned int i=0; iSetRegions(inputImage->GetLargestPossibleRegion()); image->Allocate(); eigenValueImages.push_back(image); itk::ImageRegionIterator it(image, image->GetLargestPossibleRegion()); eigenValueImageIterators.push_back(it); } itk::ImageRegionConstIterator tensorImageIterator(filter->GetOutput(), filter->GetOutput()->GetLargestPossibleRegion()); while (!tensorImageIterator.IsAtEnd()) { typename TensorImageType::PixelType::EigenValuesArrayType ev; tensorImageIterator.Get().ComputeEigenValues(ev); for (unsigned int i=0; i static void HessianEigenvalues(const itk::Image* inputImage, float sigma, std::vector outputImages) { auto spacing = inputImage->GetSpacing(); float mean_spacing = (spacing[0] + spacing[1] + spacing[2]) / 3.; typedef itk::Image ImageType; typedef itk::Image, imageDimension> TensorImageType; typename itk::HessianRecursiveGaussianImageFilter::Pointer filter = itk::HessianRecursiveGaussianImageFilter::New(); filter->SetInput(inputImage); filter->SetSigma(sigma*mean_spacing); filter->Update(); std::vector eigenValueImages; std::vector> eigenValueImageIterators; for (unsigned int i=0; iSetRegions(inputImage->GetLargestPossibleRegion()); image->Allocate(); eigenValueImages.push_back(image); itk::ImageRegionIterator it(image, image->GetLargestPossibleRegion()); eigenValueImageIterators.push_back(it); } itk::ImageRegionConstIterator tensorImageIterator(filter->GetOutput(), filter->GetOutput()->GetLargestPossibleRegion()); while (!tensorImageIterator.IsAtEnd()) { typename TensorImageType::PixelType::EigenValuesArrayType ev; tensorImageIterator.Get().ComputeEigenValues(ev); for (unsigned int i=0; i ImageType; // typedef itk::Image FeatureImageType; // auto filter = itk::HessianMatrixEigenvalueImageFilter::New(); // filter->SetInput(inputImage); // filter->SetSigma(sigma); // filter->Update(); // mitk::GrabItkImageMemory(filter->GetOutput(0), outputImages[0]); // mitk::GrabItkImageMemory(filter->GetOutput(1), outputImages[1]); // mitk::GrabItkImageMemory(filter->GetOutput(2), outputImages[2]); } /* ================================================================== * PUBLIC SLOTS * =============================================================== */ void ActiveLearning::Initialize() { // Get selected nodes and check again if these are all images m_Nodes = this->GetDataManagerSelection(); if (!SelectionAllImages(m_Nodes)) return; m_Controls.m_InitializePushButton->setDisabled(true); emit SignalSetProgressMaximum(m_Nodes.length() * 10 + 1); // 6 is number of features, shouldn't be hardcoded emit SignalResetProgress(); // Set names to the label (again) QString nameList = QString::fromStdString(m_Nodes[0]->GetName()); if (m_Nodes.length() >= 2) { for (int i=1; i"); nameList += QString::fromStdString(m_Nodes[i]->GetName()); } } m_Controls.m_InitializeLabel->setText(nameList); // ======================================= // SEGMENTATION IMAGE // ======================================= m_SegmentationImage = mitk::Image::New(); try { mitk::Image::Pointer referenceImage = dynamic_cast(m_Nodes[0]->GetData()); m_SegmentationImage->Initialize(mitk::MakeScalarPixelType(), *(referenceImage->GetTimeGeometry()->Clone())); } catch (mitk::Exception& e) { MITK_ERROR << "Exception caught: " << e.GetDescription(); QMessageBox::information(m_Parent, "Error", "Could not initialize segmentation image"); return; } FillWithZeros(m_SegmentationImage); m_SegmentationNode = mitk::DataNode::New(); m_SegmentationNode->SetData(m_SegmentationImage); m_SegmentationNode->SetName("Segmentation"); m_SegmentationNode->SetColor(1., 1., 1.); m_SegmentationNode->SetBoolProperty("binary", false); m_SegmentationNode->SetProperty("reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_NEAREST)); this->GetDataStorage()->Add(m_SegmentationNode, m_Nodes[0]); // ======================================= // ANNOTATION IMAGE // ======================================= m_AnnotationImage = mitk::Image::New(); try { mitk::Image::Pointer referenceImage = dynamic_cast(m_Nodes[0]->GetData()); m_AnnotationImage->Initialize(mitk::MakeScalarPixelType(), *(referenceImage->GetTimeGeometry()->Clone())); } catch (mitk::Exception& e) { MITK_ERROR << "Exception caught: " << e.GetDescription(); QMessageBox::information(m_Parent, "Error", "Could not initialize annotation image"); return; } FillWithZeros(m_AnnotationImage); m_AnnotationNode = mitk::DataNode::New(); m_AnnotationNode->SetData(m_AnnotationImage); m_AnnotationNode->SetName("Labels"); m_AnnotationNode->SetColor(1., 1., 1.); m_AnnotationNode->SetBoolProperty("binary", false); m_AnnotationNode->SetProperty("reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_NEAREST)); m_AnnotationNode->SetProperty("opacity", mitk::FloatProperty::New(1.0f)); this->GetDataStorage()->Add(m_AnnotationNode, m_Nodes[0]); // ======================================= // UNCERTAINTY NODE // ======================================= m_UncertaintyNode = mitk::DataNode::New(); m_UncertaintyNode->SetName("Uncertainty"); m_UncertaintyNode->SetColor(0., 1., 0.95); m_UncertaintyNode->SetBoolProperty("binary", false); m_UncertaintyNode->SetProperty("opacity", mitk::FloatProperty::New(0.6)); m_UncertaintyNode->SetVisibility(false); this->GetDataStorage()->Add(m_UncertaintyNode, m_Nodes[0]); // ======================================= // UNCERTAINTY REGION NODE // ======================================= m_UncertaintyRegionNode = mitk::DataNode::New(); m_UncertaintyRegionNode->SetName("Region"); m_UncertaintyRegionNode->SetColor(1., 1., 1.); m_UncertaintyRegionNode->SetBoolProperty("binary", false); m_UncertaintyRegionNode->SetProperty("opacity", mitk::FloatProperty::New(0.8)); m_UncertaintyRegionNode->SetVisibility(true); m_UncertaintyRegionNode->SetBoolProperty("fixedLayer", true); m_UncertaintyRegionNode->SetProperty("layer", mitk::IntProperty::New(99)); this->GetDataStorage()->Add(m_UncertaintyRegionNode, m_Nodes[0]); // Convert input images to FeaturePixelType for (auto node : m_Nodes) { mitk::Image::Pointer image = dynamic_cast(node->GetData()); auto itkImage = itk::Image::New(); mitk::CastToItkImage(image, itkImage); mitk::GrabItkImageMemory(itkImage, image); node->SetData(image); } emit SignalSetProgress(1); // Calculate features for (const auto node : m_Nodes) { mitk::Image::Pointer currentImage = dynamic_cast(node->GetData()); QFuture>> future; future = QtConcurrent::run(this, &ActiveLearning::CalculateFeatures, currentImage); auto futureWatcher = new QFutureWatcher>>(); futureWatcher->setFuture(future); connect(futureWatcher, SIGNAL(finished()), this, SLOT(OnInitializationFinished())); m_FeatureCalculationWatchers.push_back(futureWatcher); } // Interactor auto activeLearningLib = us::ModuleRegistry::GetModule("MitkCLActiveLearning"); m_Interactor = mitk::ActiveLearningInteractor::New(); m_Interactor->LoadStateMachine("Paint.xml", activeLearningLib); m_Interactor->SetEventConfig("PaintConfig.xml", activeLearningLib); m_Interactor->SetDataNode(m_AnnotationNode); // Automatically add first label OnAddLabelPushButtonClicked(); m_Active = true; } /* ================================================================== * PUBLIC * =============================================================== */ ActiveLearning::ActiveLearning() : m_Parent(nullptr), m_AnnotationImage(nullptr), m_AnnotationNode(nullptr), m_SegmentationImage(nullptr), m_SegmentationNode(nullptr), m_Active(false), m_Guidance(false), m_NumberOfTrees(50), m_MaximumTreeDepth(10), m_SamplesPerTree(0.66), - m_PredictionMatrix(nullptr) + m_PredictionMatrix(nullptr), + m_Logger() { } ActiveLearning::~ActiveLearning() { } void ActiveLearning::CreateQtPartControl( QWidget *parent ) { m_Controls.setupUi(parent); m_Parent = parent; // Label model m_LabelListModel = new QStandardItemModel(0, 3, this); m_Controls.m_LabelTableView->setModel(m_LabelListModel); m_Controls.m_LabelTableView->horizontalHeader()->setDefaultSectionSize(20); m_Controls.m_LabelTableView->verticalHeader()->setDefaultSectionSize(20); NotEditableDelegate* itemDelegate = new NotEditableDelegate(parent); m_Controls.m_LabelTableView->setItemDelegateForColumn(1, itemDelegate); // Connects connect(m_Controls.m_LabelTableView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(OnColorIconDoubleClicked(QModelIndex))); connect(m_Controls.m_LabelTableView->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)), this, SLOT(OnLabelListSelectionChanged(QItemSelection, QItemSelection))); connect(m_LabelListModel, SIGNAL(dataChanged(QModelIndex, QModelIndex)), this, SLOT(OnLabelNameChanged(QModelIndex, QModelIndex))); connect(m_Controls.m_InitializePushButton, SIGNAL(clicked()), this, SLOT(Initialize())); connect(m_Controls.m_AddLabelPushButton, SIGNAL(clicked()), this, SLOT(OnAddLabelPushButtonClicked())); connect(m_Controls.m_RemoveLabelPushButton, SIGNAL(clicked()), this, SLOT(OnRemoveLabelPushButtonClicked())); connect(m_Controls.m_PaintToolButton, SIGNAL(clicked()), this, SLOT(OnPaintToolButtonClicked())); connect(m_Controls.m_EraseToolButton, SIGNAL(clicked()), this, SLOT(OnEraseToolButtonClicked())); connect(m_Controls.m_SaveSegmentationPushButton, SIGNAL(clicked()), this, SLOT(OnSaveSegmentationPushButtonClicked())); connect(m_Controls.m_SavePredictionsPushButton, SIGNAL(clicked()), this, SLOT(OnSavePredictionsPushButtonClicked())); connect(m_Controls.m_UpdatePredictionsPushButton, SIGNAL(clicked()), this, SLOT(OnUpdatePredictionsPushButtonClicked())); connect(this, SIGNAL(SignalIncrementProgress()), this, SLOT(OnSignalIncrementProgress())); connect(this, SIGNAL(SignalSetProgress(int)), this, SLOT(OnSignalSetProgress(int))); connect(this, SIGNAL(SignalResetProgress()), this, SLOT(OnSignalResetProgress())); connect(this, SIGNAL(SignalSetProgressMaximum(int)), this, SLOT(OnSignalSetProgressMaximum(int))); connect(m_Controls.m_BrushSizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnBrushSizeSliderValueChanged(int))); connect(m_Controls.m_ActiveGuidanceCheckBox, SIGNAL(stateChanged(int)), this, SLOT(OnActiveGuidanceCheckBoxToggled(int))); + connect(m_Controls.m_LoggerToolButton, SIGNAL(clicked()), + this, SLOT(OnLoggerToolButtonClicked())); // Set start configuration m_Controls.m_LabelControlsFrame->setVisible(false); SetInitializeReady(false); } void ActiveLearning::ResetLabels() { for (int i=0; irowCount(); i++) { m_LabelListModel->item(i, 1)->setText(QString::number(i + 1)); } } std::vector > ActiveLearning::CalculateFeatures(const mitk::Image::Pointer inputImage) { std::vector> result; // TODO: Get features from preference page std::vector sigmas = {0.7, 1.6}; for (auto sigma : sigmas) { std::stringstream ss; auto gaussImage = mitk::Image::New(); AccessByItk_n(inputImage, GaussianSmoothing, (sigma, gaussImage)); gaussImage->SetClonedTimeGeometry(inputImage->GetTimeGeometry()); ss << "GaussianSmoothing (" << std::fixed << std::setprecision(2) << sigma << ")"; result.push_back(std::pair(gaussImage, ss.str())); ss.str(""); emit SignalIncrementProgress(); auto gradMagImage = mitk::Image::New(); AccessByItk_n(inputImage, GaussianGradientMagnitude, (sigma, gradMagImage)); gradMagImage->SetClonedTimeGeometry(inputImage->GetTimeGeometry()); ss << "GaussianGradientMagnitude (" << std::fixed << std::setprecision(2) << sigma << ")"; result.push_back(std::pair(gradMagImage, ss.str())); ss.str(""); emit SignalIncrementProgress(); auto logImage = mitk::Image::New(); AccessByItk_n(inputImage, LaplacianOfGaussian, (sigma, logImage)); logImage->SetClonedTimeGeometry(inputImage->GetTimeGeometry()); ss << "LaplacianOfGaussian (" << std::fixed << std::setprecision(2) << sigma << ")"; result.push_back(std::pair(logImage, ss.str())); ss.str(""); emit SignalIncrementProgress(); auto structImage1 = mitk::Image::New(); auto structImage2 = mitk::Image::New(); auto structImage3 = mitk::Image::New(); std::vector structImages = {structImage1, structImage2, structImage3}; AccessByItk_n(inputImage, StructureTensorEigenvalues, (sigma, structImages)); structImage1->SetClonedTimeGeometry(inputImage->GetTimeGeometry()); structImage2->SetClonedTimeGeometry(inputImage->GetTimeGeometry()); structImage3->SetClonedTimeGeometry(inputImage->GetTimeGeometry()); ss << "StructureTensorEV1 (" << std::fixed << std::setprecision(2) << sigma << ")"; result.push_back(std::pair(structImage1, ss.str())); ss.str(""); ss << "StructureTensorEV2 (" << std::fixed << std::setprecision(2) << sigma << ")"; result.push_back(std::pair(structImage2, ss.str())); ss.str(""); if (inputImage->GetDimension() == 3) { ss << "StructureTensorEV3 (" << std::fixed << std::setprecision(2) << sigma << ")"; result.push_back(std::pair(structImage3, ss.str())); ss.str(""); } emit SignalIncrementProgress(); auto hessianImage1 = mitk::Image::New(); auto hessianImage2 = mitk::Image::New(); auto hessianImage3 = mitk::Image::New(); std::vector hessianImages = {hessianImage1, hessianImage2, hessianImage3}; AccessByItk_n(inputImage, HessianEigenvalues, (sigma, hessianImages)); hessianImage1->SetClonedTimeGeometry(inputImage->GetTimeGeometry()); hessianImage2->SetClonedTimeGeometry(inputImage->GetTimeGeometry()); hessianImage3->SetClonedTimeGeometry(inputImage->GetTimeGeometry()); ss << "HessianEV1 (" << std::fixed << std::setprecision(2) << sigma << ")"; result.push_back(std::pair(hessianImage1, ss.str())); ss.str(""); ss << "HessianEV2 (" << std::fixed << std::setprecision(2) << sigma << ")"; result.push_back(std::pair(hessianImage2, ss.str())); ss.str(""); if (inputImage->GetDimension() == 3) { ss << "HessianEV3 (" << std::fixed << std::setprecision(2) << sigma << ")"; result.push_back(std::pair(hessianImage3, ss.str())); ss.str(""); } emit SignalIncrementProgress(); } return result; } std::pair> ActiveLearning::CalculatePrediction(const mitk::Image::Pointer annotationImage, const std::vector &featureImageVector, const mitk::Image::Pointer referenceImage, mitk::AbstractClassifier* classifier, std::shared_ptr predictionMatrix) { // Create prediction matrix if necessary if (predictionMatrix == nullptr) { FeatureMatrixType mat = Transform(featureImageVector); predictionMatrix = std::make_shared(mat); } emit SignalIncrementProgress(); // Get training data and train auto training = GetTrainingData(annotationImage, featureImageVector); classifier->Train(*training.second, *training.first); emit SignalIncrementProgress(); // Get result LabelVectorType segmentation = classifier->Predict(*predictionMatrix); emit SignalIncrementProgress(); FeatureMatrixType prediction = classifier->GetPointWiseProbabilities(); mitk::Image::Pointer segmentationImage = Transform(segmentation, referenceImage); std::vector predictionImages = Transform(prediction, referenceImage); emit SignalIncrementProgress(); std::pair> result = std::make_pair(segmentationImage, predictionImages); return result; } std::pair ActiveLearning::CalculateUncertainty(const std::vector &probabilityImageVector, const mitk::Image::Pointer referenceImage, bool guidance) { typedef itk::Image ImageType; std::vector itkImages; std::vector> iterators; for (auto image : probabilityImageVector) { typename ImageType::Pointer itkImage; mitk::CastToItkImage(image, itkImage); itkImages.push_back(itkImage); itk::ImageRegionConstIterator it(itkImage, itkImage->GetLargestPossibleRegion()); iterators.push_back(it); } auto outputImage = mitk::Image::New(); outputImage->Initialize(mitk::MakeScalarPixelType(), *(referenceImage->GetTimeGeometry()->Clone())); typename ImageType::Pointer uncertaintyImage; mitk::CastToItkImage(outputImage, uncertaintyImage); itk::ImageRegionIterator uit(uncertaintyImage, uncertaintyImage->GetLargestPossibleRegion()); while (!uit.IsAtEnd()) { FeaturePixelType value = 0; for (unsigned int i=0; iInitialize(mitk::MakeScalarPixelType(), *(referenceImage->GetTimeGeometry()->Clone())); auto regionFilter = mitk::ActiveLearningSuggestRegionFilter>::New(); regionFilter->SetInput(uncertaintyImage); regionFilter->SetThreshold(0.5); regionFilter->Update(); mitk::GrabItkImageMemory(regionFilter->GetOutput(), region); } mitk::GrabItkImageMemory(uncertaintyImage, outputImage); std::pair result = std::make_pair(outputImage, region); return result; } std::pair, std::shared_ptr> ActiveLearning::GetTrainingData(const mitk::Image::Pointer annotationImage, const std::vector &featureImageVector) { // Get indices and labels std::vector> indices; std::vector labels; itk::Image::Pointer annotationImageItk; mitk::CastToItkImage(annotationImage, annotationImageItk); itk::ImageRegionIteratorWithIndex> it(annotationImageItk, annotationImageItk->GetLargestPossibleRegion()); while (!it.IsAtEnd()) { if (it.Get() != 0) { indices.push_back(it.GetIndex()); labels.push_back(it.Get()); } ++it; } FeatureMatrixType trainingData(indices.size(), featureImageVector.size()); LabelVectorType trainingLabels = LabelVectorType::Map(labels.data(), labels.size()); int j = 0; for (mitk::Image::Pointer feature : featureImageVector) { int i = 0; mitk::ImagePixelReadAccessor access(feature, feature->GetVolumeData()); for (auto index : indices) { trainingData(i, j) = access.GetPixelByIndexSafe(index); i++; } j++; } auto trainingLabelsPtr = std::make_shared(trainingLabels); auto trainingDataPtr = std::make_shared(trainingData); std::pair, std::shared_ptr> result = std::make_pair(trainingLabelsPtr, trainingDataPtr); return result; } void ActiveLearning::UpdateLookupTables() { // Create new lookup table from list // Annotation type is int, but we only use a ushort lookup table auto lut = vtkSmartPointer::New(); int lowlim = std::numeric_limits::min(); int uplim = std::numeric_limits::max(); lut->SetNumberOfTableValues(uplim - lowlim + 1); lut->SetTableRange(lowlim, uplim); for (long i=0; i<(uplim-lowlim+1); ++i) { lut->SetTableValue(i, 0.0, 0.0, 0.0, 0.0); } for (int j=0; jrowCount(); ++j) { int value = m_LabelListModel->item(j, 1)->text().toInt(); const QColor color = m_LabelListModel->item(j, 0)->background().color(); lut->SetTableValue(value, color.redF(), color.greenF(), color.blueF(), 1.0); } auto lutMitk = mitk::LookupTable::New(); lutMitk->SetVtkLookupTable(lut); // Set to annotation image and segmentation image auto * lut_prop = dynamic_cast(m_AnnotationNode->GetProperty("LookupTable")); lut_prop->SetLookupTable(lutMitk); m_AnnotationNode->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New(mitk::RenderingModeProperty::LOOKUPTABLE_COLOR)); m_AnnotationNode->Modified(); lut_prop = dynamic_cast(m_SegmentationNode->GetProperty("LookupTable")); lut_prop->SetLookupTable(lutMitk); m_SegmentationNode->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New(mitk::RenderingModeProperty::LOOKUPTABLE_COLOR)); m_SegmentationNode->Modified(); } void ActiveLearning::UpdatePredictionNodes() { if (m_LabelListModel->rowCount() == 0) return; // Build lookup table vtkSmartPointer lut = vtkSmartPointer::New(); lut->SetTableRange (0, 1); lut->SetSaturationRange (0, 0); lut->SetHueRange (0, 0); lut->SetValueRange (0, 1); lut->SetAlphaRange (0, 1); lut->Build(); auto lutMitk = mitk::LookupTable::New(); lutMitk->SetVtkLookupTable(lut); for (int i=0; irowCount(); ++i) { auto property = mitk::NodePredicateProperty::New("segmentation_value", mitk::IntProperty::New(m_LabelListModel->item(i, 1)->text().toInt())); auto nodes = this->GetDataStorage()->GetDerivations(m_Nodes[0], property); if (nodes->Size() == 1) { auto node = nodes->GetElement(0); QString name = "Prediction "; name += m_LabelListModel->item(i, 2)->text(); node->SetName(name.toStdString()); auto * lut_prop = dynamic_cast(node->GetProperty("LookupTable")); lut_prop->SetLookupTable(lutMitk); node->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New(mitk::RenderingModeProperty::LOOKUPTABLE_COLOR)); node->SetColor(QColorToMitkColor(m_LabelListModel->item(i, 0)->background().color())); node->Modified(); } if (nodes->Size() > 1) mitkThrow(); } // Uncertainty image auto *lut_prop = dynamic_cast(m_UncertaintyNode->GetProperty("LookupTable")); if (lut_prop != nullptr) { lut_prop->SetLookupTable(lutMitk); m_UncertaintyNode->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New(mitk::RenderingModeProperty::LOOKUPTABLE_COLOR)); } vtkSmartPointer lut2 = vtkSmartPointer::New(); lut2->SetRampToLinear(); lut2->SetSaturationRange (0., 0.); lut2->SetHueRange (0., 0.); lut2->SetValueRange (0., 1.); lut2->SetAlphaRange (1., 0.); lut2->Build(); auto lutMitk2 = mitk::LookupTable::New(); lutMitk2->SetVtkLookupTable(lut2); lut_prop = dynamic_cast(m_UncertaintyRegionNode->GetProperty("LookupTable")); if (lut_prop != nullptr) { lut_prop->SetLookupTable(lutMitk2); m_UncertaintyRegionNode->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New(mitk::RenderingModeProperty::LOOKUPTABLE_COLOR)); } mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } const std::string ActiveLearning::VIEW_ID = "org.mitk.views.activelearning"; /* ================================================================== * PROTECTED SLOTS * =============================================================== */ void ActiveLearning::OnSignalIncrementProgress() { m_Controls.m_ProgressBar->setValue(m_Controls.m_ProgressBar->value() + 1); } void ActiveLearning::OnSignalSetProgress(int value) { m_Controls.m_ProgressBar->setValue(value); } void ActiveLearning::OnSignalResetProgress() { m_Controls.m_ProgressBar->setValue(0); } void ActiveLearning::OnSignalSetProgressMaximum(int value) { m_Controls.m_ProgressBar->setMaximum(value); } void ActiveLearning::OnAddLabelPushButtonClicked() { QString labelName = QString("Label ") + QString::number(m_LabelListModel->rowCount() + 1); QColor labelColor = Qt::GlobalColor(m_LabelListModel->rowCount() % 12 + 7); // We only want Qt default colors 7 to 18 // Create icon QStandardItem* colorSquare = new QStandardItem; colorSquare->setBackground(labelColor); colorSquare->setEditable(false); QPixmap colorPixmap(20, 20); colorPixmap.fill(labelColor); colorSquare->setIcon(QIcon(colorPixmap)); // Key is the highest existing key + 1 int value = 1; if (m_LabelListModel->rowCount() >= 1) { value = m_LabelListModel->item(m_LabelListModel->rowCount() - 1, 1)->text().toInt() + 1; } QStandardItem* valueItem = new QStandardItem; valueItem->setText(QString::number(value)); // Create label item QStandardItem* label = new QStandardItem(labelName); // Make list and insert QList list; list.append(colorSquare); list.append(valueItem); list.append(label); m_LabelListModel->appendRow(list); m_Controls.m_LabelTableView->selectRow(m_LabelListModel->rowCount() - 1); // If this is the first label, we activate the paint button // We also have to set the data node color for this one, because for 1 values that color seems to define the rendered color if (m_LabelListModel->rowCount() == 1) { OnPaintToolButtonClicked(); } // Update colors UpdateLookupTables(); } void ActiveLearning::OnRemoveLabelPushButtonClicked() { // can't remove last label if (m_LabelListModel->rowCount() <= 1) return; QItemSelectionModel* selection = m_Controls.m_LabelTableView->selectionModel(); if (selection->hasSelection()) { unsigned int removeIndex = selection->selectedRows().first().row(); QString removeMessage = QString("Remove label '") + m_LabelListModel->item(removeIndex, 2)->text() + QString("'?"); QMessageBox::StandardButton removeReply; removeReply = QMessageBox::question(m_Parent, "Remove Label", removeMessage, QMessageBox::Yes | QMessageBox::No); if (removeReply == QMessageBox::Yes) { AnnotationPixelType removeValue = m_LabelListModel->item(removeIndex, 1)->text().toInt(); m_LabelListModel->removeRow(removeIndex); if (!m_Interactor->IsUsed()) { ResetLabels(); } else { itk::Image::Pointer imageItk; mitk::CastToItkImage(m_AnnotationImage, imageItk); auto it = itk::ImageRegionIterator>(imageItk, imageItk->GetLargestPossibleRegion()); while (!it.IsAtEnd()) { if (it.Get() == removeValue) it.Set(0); ++it; } mitk::GrabItkImageMemory(imageItk, m_AnnotationImage); UpdateLookupTables(); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } } } void ActiveLearning::OnPaintToolButtonClicked() { m_Controls.m_PaintToolButton->setChecked(true); QItemSelectionModel* selection = m_Controls.m_LabelTableView->selectionModel(); int row(0); if (selection->hasSelection()) { row = selection->selectedRows().first().row(); } else { m_Controls.m_LabelTableView->selectRow(0); } m_Interactor->SetPaintingPixelValue(m_LabelListModel->item(row, 1)->text().toInt()); } void ActiveLearning::OnEraseToolButtonClicked() { m_Controls.m_EraseToolButton->setChecked(true); m_Interactor->SetPaintingPixelValue(0); } void ActiveLearning::OnSaveSegmentationPushButtonClicked() { auto newNode = mitk::DataNode::New(); newNode->SetName("Segmentation"); newNode->SetBoolProperty("binary", false); newNode->SetOpacity(1.0); newNode->SetVisibility(false); newNode->SetData(m_SegmentationImage->Clone()); this->GetDataStorage()->Add(newNode); } void ActiveLearning::OnSavePredictionsPushButtonClicked() { if (m_LabelListModel->rowCount() < 1) return; for (int i=0; irowCount(); ++i) { auto property = mitk::NodePredicateProperty::New("segmentation_value", mitk::IntProperty::New(m_LabelListModel->item(i, 1)->text().toInt())); auto nodes = this->GetDataStorage()->GetDerivations(m_Nodes[0], property); if (nodes->Size() == 1) { auto sourceNode = nodes->GetElement(0); mitk::Image::Pointer sourceImage = dynamic_cast(sourceNode->GetData()); auto newNode = mitk::DataNode::New(); QString name = "Prediction "; name += m_LabelListModel->item(i, 2)->text(); newNode->SetName(name.toStdString()); newNode->SetBoolProperty("binary", false); newNode->SetOpacity(1.0); newNode->SetVisibility(false); newNode->SetProperty("segmentation_value", mitk::IntProperty::New(m_LabelListModel->item(i, 1)->text().toInt())); newNode->SetData(sourceImage->Clone()); this->GetDataStorage()->Add(newNode); } if (nodes->Size() > 1) mitkThrow(); } } void ActiveLearning::OnActiveGuidanceCheckBoxToggled(int toggled) { m_Guidance = (toggled > 0); } void ActiveLearning::OnColorIconDoubleClicked(const QModelIndex& index) { // Check if click is really from color icon if (index.column() != 0) { return; } else { // Color change dialog QColor setColor = QColorDialog::getColor(m_LabelListModel->itemFromIndex(index)->background().color(), m_Parent, "Select Label Color"); if (setColor.isValid()) { m_LabelListModel->itemFromIndex(index)->setBackground(setColor); QPixmap colorPixmap(20, 20); colorPixmap.fill(setColor); m_LabelListModel->itemFromIndex(index)->setIcon(QIcon(colorPixmap)); UpdateLookupTables(); UpdatePredictionNodes(); } } } void ActiveLearning::OnLabelListSelectionChanged(const QItemSelection& selected, const QItemSelection& /*deselected*/) { if (selected.empty()) return; if (m_Controls.m_EraseToolButton->isChecked()) OnPaintToolButtonClicked(); // This assumes that only one item can be selected (single selection table view) try { int labelValue = m_LabelListModel->item(selected.indexes()[0].row(), 1)->text().toInt(); m_Interactor->SetPaintingPixelValue(labelValue); } catch (...) { m_Interactor->SetPaintingPixelValue(-1); } } void ActiveLearning::OnLabelNameChanged(const QModelIndex& topLeft, const QModelIndex& /*bottomRight*/) { UpdatePredictionNodes(); } void ActiveLearning::OnInitializationFinished() { // Check if all futures are finished for (auto watcher : m_FeatureCalculationWatchers) { if (watcher->isFinished() == false) {return;} } // Empty feature vector m_FeatureImageVector.clear(); // Insert features into feature vector and data storage for (unsigned int i=0; iresult(); for (unsigned int j=0; jSetData(result[j].first); node->SetName(result[j].second); node->SetBoolProperty("helper object", true); node->SetVisibility(false); this->GetDataStorage()->Add(node, m_Nodes[i]); } } // Show controls m_Controls.m_LabelControlsFrame->setVisible(true); m_Controls.m_InitializePushButton->setHidden(true); emit SignalResetProgress(); // Delete watchers for (auto watcher : m_FeatureCalculationWatchers) { delete watcher; } m_FeatureCalculationWatchers.clear(); } +void ActiveLearning::OnLoggerToolButtonClicked() +{ + QString directory = QFileDialog::getExistingDirectory(nullptr, QString("Select logging directory"), QDir::currentPath(), + QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks); + if (QDir(directory).exists()) + { + m_Logger.SetLoggingDirectory(directory); + m_Controls.m_LoggerLabel->setText(directory); + } +} + void ActiveLearning::OnUpdatePredictionsPushButtonClicked() { if (m_LabelListModel->rowCount() < 1) return; m_Controls.m_UpdatePredictionsPushButton->setDisabled(true); emit SignalSetProgressMaximum(4); // Clear old predictions for (int i=0; irowCount(); ++i) { auto property = mitk::NodePredicateProperty::New("segmentation_value", mitk::IntProperty::New(m_LabelListModel->item(i, 1)->text().toInt())); auto nodes = this->GetDataStorage()->GetDerivations(m_Nodes[0], property); if (nodes->Size() == 1) { this->GetDataStorage()->Remove(nodes); } if (nodes->Size() > 1) mitkThrow(); } // Classifier auto classifier = mitk::VigraRandomForestClassifier::New(); classifier->SetTreeCount(m_NumberOfTrees); classifier->SetMaximumTreeDepth(m_MaximumTreeDepth); classifier->SetSamplesPerTree(m_SamplesPerTree); mitk::Image::Pointer referenceImage = dynamic_cast(m_Nodes[0]->GetData()); QFuture>> future; future = QtConcurrent::run(this, &ActiveLearning::CalculatePrediction, m_AnnotationImage, m_FeatureImageVector, referenceImage, classifier, m_PredictionMatrix); m_PredictionCalculationWatcher = new QFutureWatcher>>(); m_PredictionCalculationWatcher->setFuture(future); connect(m_PredictionCalculationWatcher, SIGNAL(finished()), this, SLOT(OnPredictionCalculationFinished())); } void ActiveLearning::OnPredictionCalculationFinished() { auto result = m_PredictionCalculationWatcher->result(); m_SegmentationImage = result.first; m_SegmentationImage->Modified(); m_SegmentationNode->SetData(m_SegmentationImage); m_SegmentationNode->Modified(); for (unsigned int i=0; iitem(i, 2)->text(); node->SetName(name.toStdString()); node->SetBoolProperty("binary", false); node->SetVisibility(false); node->SetOpacity(0.3); node->SetColor(QColorToMitkColor(m_LabelListModel->item(i, 0)->background().color())); node->SetProperty("segmentation_value", mitk::IntProperty::New(m_LabelListModel->item(i, 1)->text().toInt())); node->SetData(result.second[i]); this->GetDataStorage()->Add(node, m_Nodes[0]); } QFuture> future; future = QtConcurrent::run(this, &ActiveLearning::CalculateUncertainty, result.second, m_SegmentationImage, m_Guidance); m_UncertaintyCalculationWatcher = new QFutureWatcher>(); m_UncertaintyCalculationWatcher->setFuture(future); connect(m_UncertaintyCalculationWatcher, SIGNAL(finished()), this, SLOT(OnUncertaintyCalculationFinished())); } void ActiveLearning::OnUncertaintyCalculationFinished() { m_UncertaintyImage = m_UncertaintyCalculationWatcher->result().first; m_UncertaintyImage->Modified(); m_UncertaintyNode->SetData(m_UncertaintyImage); m_UncertaintyNode->Modified(); if (m_UncertaintyCalculationWatcher->result().second.IsNotNull()) { m_UncertaintyRegion = m_UncertaintyCalculationWatcher->result().second; m_UncertaintyRegion->Modified(); m_UncertaintyRegionNode->SetData(m_UncertaintyRegion); m_UncertaintyRegionNode->Modified(); } UpdateLookupTables(); UpdatePredictionNodes(); emit SignalResetProgress(); m_Controls.m_UpdatePredictionsPushButton->setEnabled(true); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void ActiveLearning::OnBrushSizeSliderValueChanged(int value) { QString labelText = "Size "; labelText += QString::number(value); m_Controls.m_BrushSizeLabel->setText(labelText); m_Interactor->SetSize(value); } /* ================================================================== * PROTECTED * =============================================================== */ void ActiveLearning::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/, const QList& nodes) { if (!SelectionAllImages(nodes)) { SetInitializeReady(false); return; } if (nodes.length() >= 2) { // First selection is the reference (could be any other) mitk::Image::Pointer referenceImage = dynamic_cast(nodes[0]->GetData()); mitk::BaseGeometry* referenceGeometry = referenceImage->GetTimeGeometry()->GetGeometryForTimeStep(0); // Adjust for multiple timesteps for (int i=1; i(nodes[i]->GetData()); mitk::BaseGeometry* currentGeometry = currentImage->GetTimeGeometry()->GetGeometryForTimeStep(0); // Adjust for multiple timesteps if (!mitk::Equal(*currentGeometry, *referenceGeometry, mitk::eps, true)) { SetInitializeReady(false); return; } } } // All nodes have the same geometry, allow init SetInitializeReady(true); } void ActiveLearning::SetFocus() { } /* ================================================================== * PRIVATE * =============================================================== */ void ActiveLearning::SetInitializeReady(bool ready) { if (ready) { // get selection, check again just to be sure auto nodes = this->GetDataManagerSelection(); if (!SelectionAllImages(nodes)) return; m_Controls.m_InitializePushButton->setEnabled(true); if (!m_Active) { QString nameList = QString::fromStdString(nodes[0]->GetName()); if (nodes.length() >= 2) { for (int i=1; i"); nameList += QString::fromStdString(nodes[i]->GetName()); } } m_Controls.m_InitializeLabel->setText(nameList); } } else { m_Controls.m_InitializePushButton->setDisabled(true); if (!m_Active) { m_Controls.m_InitializeLabel->setText("Selected images must have matching geometries"); } } } diff --git a/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.h b/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.h index 142f1bd8e6..9da6db1b41 100644 --- a/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.h +++ b/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearning.h @@ -1,202 +1,207 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef ActiveLearning_h #define ActiveLearning_h #include #include #include "ui_QmitkActiveLearningControls.h" // Qt #include #include #include #include // MITK #include #include #include +#include "QmitkActiveLearningLogger.h" #include /** \brief ActiveLearning \warning This class is not yet documented. Use "git blame" and ask the author to provide basic documentation. \sa QmitkAbstractView \ingroup ${plugin_target}_internal */ // Just a helper class class NotEditableDelegate : public QItemDelegate { Q_OBJECT public: explicit NotEditableDelegate(QObject* parent = nullptr) : QItemDelegate(parent) {} protected: QWidget* createEditor(QWidget*, const QStyleOptionViewItem&, const QModelIndex&) const {return Q_NULLPTR;} }; class ActiveLearning : public QmitkAbstractView { Q_OBJECT public slots: void Initialize(); public: typedef unsigned short AnnotationPixelType; typedef double FeaturePixelType; typedef int LabelPixelType; typedef Eigen::Matrix FeatureMatrixType; typedef Eigen::Matrix LabelVectorType; ActiveLearning(); ~ActiveLearning(); void CreateQtPartControl(QWidget *parent) override; std::vector> CalculateFeatures(const mitk::Image::Pointer inputImage); std::pair > CalculatePrediction(const mitk::Image::Pointer annotationImage, const std::vector &featureImageVector, const mitk::Image::Pointer referenceImage, mitk::AbstractClassifier *classifier, std::shared_ptr predictionMatrix); std::pair, std::shared_ptr > GetTrainingData(const mitk::Image::Pointer annotationImage, const std::vector &featureImageVector); std::pair CalculateUncertainty(const std::vector &probabilityImageVector, const mitk::Image::Pointer referenceImage, bool guidance); void UpdateLookupTables(); void UpdatePredictionNodes(); static const std::string VIEW_ID; signals: void SignalIncrementProgress(); void SignalSetProgress(int value); void SignalResetProgress(); void SignalSetProgressMaximum(int value); protected slots: void OnSignalIncrementProgress(); void OnSignalSetProgress(int value); void OnSignalResetProgress(); void OnSignalSetProgressMaximum(int value); void OnAddLabelPushButtonClicked(); void OnRemoveLabelPushButtonClicked(); void OnPaintToolButtonClicked(); void OnEraseToolButtonClicked(); void OnSaveSegmentationPushButtonClicked(); void OnSavePredictionsPushButtonClicked(); void OnActiveGuidanceCheckBoxToggled(int toggled); void OnColorIconDoubleClicked(const QModelIndex& index); void OnLabelListSelectionChanged(const QItemSelection& selected, const QItemSelection& /*deselected*/); void OnLabelNameChanged(const QModelIndex& topLeft, const QModelIndex& /*bottomRight*/); void OnBrushSizeSliderValueChanged(int value); void OnUpdatePredictionsPushButtonClicked(); void OnPredictionCalculationFinished(); void OnUncertaintyCalculationFinished(); void OnInitializationFinished(); + void OnLoggerToolButtonClicked(); + protected: void OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/, const QList& nodes) override; void SetFocus() override; void ResetLabels(); void SetInitializeReady(bool ready); Ui::ActiveLearningControls m_Controls; QWidget* m_Parent; mitk::Image::Pointer m_AnnotationImage; mitk::DataNode::Pointer m_AnnotationNode; mitk::Image::Pointer m_SegmentationImage; mitk::DataNode::Pointer m_SegmentationNode; mitk::Image::Pointer m_UncertaintyImage; mitk::DataNode::Pointer m_UncertaintyNode; mitk::Image::Pointer m_UncertaintyRegion; mitk::DataNode::Pointer m_UncertaintyRegionNode; std::vector m_FeatureImageVector; std::vector>>*> m_FeatureCalculationWatchers; QFutureWatcher>>* m_PredictionCalculationWatcher; QFutureWatcher>* m_UncertaintyCalculationWatcher; QStandardItemModel* m_LabelListModel; mitk::ActiveLearningInteractor::Pointer m_Interactor; + ActiveLearningLogger m_Logger; + QList m_Nodes; bool m_Active; bool m_Guidance; int m_NumberOfTrees; int m_MaximumTreeDepth; float m_SamplesPerTree; std::shared_ptr m_PredictionMatrix; }; #endif // ActiveLearning_h diff --git a/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearningControls.ui b/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearningControls.ui index 2940b133e7..07cbdb7ae2 100644 --- a/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearningControls.ui +++ b/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearningControls.ui @@ -1,554 +1,610 @@ ActiveLearningControls 0 0 352 581 0 0 QmitkTemplate Initialize with selection false false false false <font color="red">Selection must have matching dimensions and transforms</font> true QFrame::NoFrame QFrame::Raised 0 0 0 0 Qt::Vertical QSizePolicy::Fixed 20 10 QFrame::Sunken 1 Qt::Horizontal Qt::Vertical QSizePolicy::Fixed 20 10 QFrame::NoFrame QFrame::Raised 0 0 0 0 Add Label Remove Label Qt::Horizontal 40 20 QFrame::Sunken false QAbstractItemView::SingleSelection QAbstractItemView::SelectRows false true false QFrame::NoFrame QFrame::Raised 0 0 0 0 0 0 0 40 :/org.mitk.gui.qt.activelearning/resources/paint_icon_200.png:/org.mitk.gui.qt.activelearning/resources/paint_icon_200.png 25 25 true true 0 0 0 40 ... :/org.mitk.gui.qt.activelearning/resources/erase_icon_100.png:/org.mitk.gui.qt.activelearning/resources/erase_icon_100.png 25 25 true true QFrame::NoFrame QFrame::Raised 0 0 0 0 0 0 52 0 Size 1 1 20 Qt::Horizontal Active Guidance 0 40 Update + + + + QFrame::NoFrame + + + QFrame::Plain + + + + 0 + + + 0 + + + 0 + + + 0 + + + 0 + + + + + Log + + + + + + + Set logging directory + + + false + + + Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter + + + true + + + 0 + + + 10 + + + + + + Qt::Vertical QSizePolicy::Fixed 20 10 Qt::Horizontal Qt::Vertical QSizePolicy::Fixed 20 10 Save to Data Manager QFrame::NoFrame QFrame::Raised 0 0 0 0 Segmentation Predictions QFrame::NoFrame QFrame::Raised 0 0 0 0 Qt::Vertical QSizePolicy::Fixed 20 10 Qt::Horizontal Qt::Vertical QSizePolicy::Fixed 20 10 0 false false Qt::Vertical 20 40 diff --git a/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearningLogger.cpp b/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearningLogger.cpp new file mode 100644 index 0000000000..b627bf47d9 --- /dev/null +++ b/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearningLogger.cpp @@ -0,0 +1,110 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +// Qmitk +#include "QmitkActiveLearningLogger.h" + +#include +#include +#include + +#include + +ActiveLearningLogger::ActiveLearningLogger() : + m_LoggingDirectory(""), + m_LoggingPrefix(""), + m_LoggingPath("") +{ +} + +ActiveLearningLogger::ActiveLearningLogger(QString directory) : + m_LoggingDirectory(""), + m_LoggingPrefix(""), + m_LoggingPath("") +{ + SetLoggingDirectory(directory); +} + +ActiveLearningLogger::~ActiveLearningLogger() +{ +} + +void ActiveLearningLogger::SetLoggingDirectory(const QString directory) +{ + SetLoggingPath(directory, m_LoggingPrefix); +} + +void ActiveLearningLogger::SetLoggingPrefix(const QString prefix) +{ + SetLoggingPath(m_LoggingDirectory, prefix); +} + +void ActiveLearningLogger::SetLoggingPath(const QString directory, const QString prefix) +{ + if (directory == m_LoggingDirectory && prefix == m_LoggingPrefix) return; + + QString path; + if (directory.isEmpty()) + { + path = ""; + } + else + { + QString fileName = prefix + QString("_") + QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss") + QString(".txt"); + path = QDir(directory).filePath(fileName); + } + + bool pathError = SetLoggingPath(path); + if (!pathError) + { + m_LoggingDirectory = directory; + m_LoggingPrefix = prefix; + } +} + +bool ActiveLearningLogger::SetLoggingPath(const QString path) +{ + if (path.isEmpty() || QFileInfo(path).isFile()) + { + m_LoggingPath = path; + return false; + } + + return true; +} + +void ActiveLearningLogger::Write(const QString string) +{ + QString timeString = QTime::currentTime().toString("hh:mm:ss"); + Write(timeString, string); +} + +void ActiveLearningLogger::Write(const QString timeString, const QString string) +{ + QFile outFile(m_LoggingPath); + outFile.exists() ? outFile.open(QIODevice::Append | QIODevice::Text) : outFile.open(QIODevice::WriteOnly | QIODevice::Text); + QTextStream outStream(&outFile); + outStream << timeString << "\t" << string << "\n"; + outFile.close(); +} + +void ActiveLearningLogger::Write(const mitk::Image *image, QString fileName = "") +{ + QTime currentTime = QTime::currentTime(); + if (fileName.isEmpty()) fileName = currentTime.toString("hh-mm-ss") + QString(".nrrd"); + mitk::IOUtil::Save(image, QDir(m_LoggingDirectory).filePath(fileName).toStdString()); + Write(currentTime.toString("hh:mm:ss"), QString("Wrote image to ") + fileName); +} diff --git a/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearningLogger.h b/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearningLogger.h new file mode 100644 index 0000000000..f84669ad53 --- /dev/null +++ b/Plugins/org.mitk.gui.qt.activelearning/src/internal/QmitkActiveLearningLogger.h @@ -0,0 +1,74 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#ifndef ActiveLearningLogger_h +#define ActiveLearningLogger_h + +#include +#include + +#include + +/** +\brief ActiveLearningLogger + +\warning This class can be hooked up to an instance of ActiveLearning to record all interactions and images. + +\ingroup ${plugin_target}_internal +*/ + +class ActiveLearningLogger +{ + +public: + + ActiveLearningLogger(); + ActiveLearningLogger(QString directory); + ~ActiveLearningLogger(); + + QString GetLoggingDirectory(){ return m_LoggingDirectory; } + + QString GetLoggingPrefix(){ return m_LoggingPrefix; } + + QString GetLoggingPath(){ return m_LoggingPath; } + + void SetLoggingDirectory(const QString directory); + + void SetLoggingPrefix(const QString prefix); + + void SetLoggingPath(const QString directory, const QString prefix); + + bool SetLoggingPath(const QString path); + + void ResetLoggingPrefix(){ SetLoggingPrefix(""); } + + void ResetLogger(){ SetLoggingPath(""); } + +protected: + + void Write(const QString string); + + void Write(const QString timeString, const QString string); + + void Write(const mitk::Image* image, QString fileName); + + QString m_LoggingDirectory; + QString m_LoggingPrefix; + QString m_LoggingPath; + +}; + +#endif // ActiveLearningLogger_h