diff --git a/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFFirstOrderNumericStatistics.cpp b/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFFirstOrderNumericStatistics.cpp index 272874edba..57e8c57113 100644 --- a/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFFirstOrderNumericStatistics.cpp +++ b/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFFirstOrderNumericStatistics.cpp @@ -1,547 +1,358 @@ /*=================================================================== 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. ===================================================================*/ #include // MITK #include #include #include // ITK #include #include #include // STL #include struct FirstOrderNumericParameterStruct { mitk::IntensityQuantifier::Pointer quantifier; double MinimumIntensity; double MaximumIntensity; int Bins; std::string prefix; }; template void CalculateFirstOrderStatistics(itk::Image* itkImage, mitk::Image::Pointer mask, mitk::GIFFirstOrderNumericStatistics::FeatureListType & featureList, FirstOrderNumericParameterStruct params) { typedef itk::Image ImageType; typedef itk::Image MaskType; typename MaskType::Pointer maskImage = MaskType::New(); mitk::CastToItkImage(mask, maskImage); // // Calculate the Volume of Voxel (Maximum to the 3th order) // double voxelVolume = 1; for (unsigned int i = 0; i < std::min(3, VImageDimension); ++i) voxelVolume *= itkImage->GetSpacing()[i]; // // Calculate the Hypervolume of Voxel // double voxelSpace = 1; for (unsigned int i = 0; i < VImageDimension; ++i) voxelSpace *= itkImage->GetSpacing()[i]; unsigned int numberOfBins = params.quantifier->GetBins(); std::vector histogram; histogram.resize(numberOfBins, 0); double minimum = std::numeric_limits::max(); double maximum = std::numeric_limits::lowest(); + double absoluteMinimum = std::numeric_limits::max(); + double absoluteMaximum = std::numeric_limits::lowest(); double sum = 0; double sumTwo= 0; double sumThree = 0; unsigned int numberOfVoxels = 0; itk::ImageRegionIterator imageIter(itkImage, itkImage->GetLargestPossibleRegion()); itk::ImageRegionIterator maskIter(maskImage, maskImage->GetLargestPossibleRegion()); while (!imageIter.IsAtEnd()) { + double value = imageIter.Get(); + + absoluteMinimum = std::min(minimum, value); + absoluteMaximum = std::max(maximum, value); if (maskIter.Get() > 0) { - double value = imageIter.Get(); - minimum = std::min(minimum, value); maximum = std::max(maximum, value); sum += value; sumTwo += value * value; sumThree += value * value*value; histogram[params.quantifier->IntensityToIndex(value)] += 1; ++numberOfVoxels; } ++maskIter; ++imageIter; } // // Histogram based calculations // unsigned int passedValues = 0; double doubleNoOfVoxes = numberOfVoxels; double median = 0; double lastIntensityWithValues = params.quantifier->IndexToMeanIntensity(0); std::size_t modeIdx = 0; double modeValue = 0; + double entropy = 0; + double uniformity = 0; + std::vector percentiles; percentiles.resize(20, 0); for (std::size_t idx = 0; idx < histogram.size(); ++idx) { unsigned int actualValues = histogram[idx]; for (std::size_t percentileIdx = 0; percentileIdx < percentiles.size(); ++percentileIdx) { double threshold = doubleNoOfVoxes * (percentileIdx + 1) *1.0 / (percentiles.size()); if ((passedValues < threshold) & ((passedValues + actualValues) >= threshold)) { // Lower Bound if (passedValues == std::floor(threshold)) { percentiles[percentileIdx] = 0.5*(lastIntensityWithValues + params.quantifier->IndexToMeanIntensity(idx)); } else { percentiles[percentileIdx] = params.quantifier->IndexToMeanIntensity(idx); } } } if ((passedValues < doubleNoOfVoxes * 0.5) & ((passedValues + actualValues) >= doubleNoOfVoxes * 0.5)) { // Lower Bound if (passedValues == std::floor(doubleNoOfVoxes * 0.5)) { median = 0.5*(lastIntensityWithValues + params.quantifier->IndexToMeanIntensity(idx)); } else { median = params.quantifier->IndexToMeanIntensity(idx); } } if (actualValues > histogram[modeIdx]) { modeIdx = idx; } if (actualValues > 0) { lastIntensityWithValues = params.quantifier->IndexToMeanIntensity(idx); + + double currentProbability = actualValues / (1.0 *numberOfVoxels); + uniformity += currentProbability * currentProbability; + entropy += currentProbability * std::log(currentProbability) / std::log(2); } passedValues += actualValues; } double p10 = percentiles[1]; double p25idx = params.quantifier->IntensityToIndex(percentiles[4]); double p75idx = params.quantifier->IntensityToIndex(percentiles[14]); double p90 = percentiles[17]; double mean = sum / (numberOfVoxels); double variance = sumTwo / (numberOfVoxels) - (mean*mean); double energy = sumTwo; double rootMeanSquare = std::sqrt(sumTwo / numberOfVoxels); double sumAbsoluteDistanceToMean = 0; double sumAbsoluteDistanceToMedian = 0; double sumRobust = 0; double sumRobustSquare = 0; double sumRobustAbsolulteDistanceToMean = 0; double sumValueMinusMean = 0; double sumValueMinusMeanThree = 0; double sumValueMinusMeanFour = 0; unsigned int numberOfRobustVoxel = 0; maskIter.GoToBegin(); imageIter.GoToBegin(); while (!imageIter.IsAtEnd()) { if (maskIter.Get() > 0) { double value = imageIter.Get(); double valueMinusMean = value - mean; sumAbsoluteDistanceToMean += std::abs(valueMinusMean); sumAbsoluteDistanceToMedian += std::abs(value - median); sumValueMinusMean += valueMinusMean; sumValueMinusMeanThree += valueMinusMean * valueMinusMean * valueMinusMean; sumValueMinusMeanFour += valueMinusMean * valueMinusMean * valueMinusMean * valueMinusMean; if ((p10 <= value) & (value <= p90)) { sumRobust += value; sumRobustSquare += value * value; ++numberOfRobustVoxel; } } ++maskIter; ++imageIter; } double robustMean = sumRobust / numberOfRobustVoxel; double robustVariance = sumRobustSquare / numberOfRobustVoxel - (robustMean * robustMean); maskIter.GoToBegin(); imageIter.GoToBegin(); while (!imageIter.IsAtEnd()) { if (maskIter.Get() > 0) { double value = imageIter.Get(); if ((p10 <= value) & (value <= p90)) { sumRobustAbsolulteDistanceToMean += std::abs(value - robustMean); } } ++maskIter; ++imageIter; } double meanAbsoluteDeviation = sumAbsoluteDistanceToMean / numberOfVoxels; double medianAbsoluteDeviation = sumAbsoluteDistanceToMedian / numberOfVoxels; double robustMeanAbsoluteDeviation = sumRobustAbsolulteDistanceToMean / numberOfRobustVoxel; double skewness = sumValueMinusMeanThree / numberOfVoxels / variance / std::sqrt(variance); double kurtosis = sumValueMinusMeanFour / numberOfVoxels / variance / variance; double interquantileRange = p75idx - p25idx; double coefficientOfVariation = std::sqrt(variance) / mean; double quantileCoefficientOfDispersion = (p75idx - p25idx) / (p75idx + p25idx + 2); + double coveredImageRange = (absoluteMaximum - absoluteMinimum) / (maximum - minimum); featureList.push_back(std::make_pair(params.prefix + "Mean", mean)); featureList.push_back(std::make_pair(params.prefix + "Variance", variance)); featureList.push_back(std::make_pair(params.prefix + "Skewness", skewness)); featureList.push_back(std::make_pair(params.prefix + "Excess kurtosis", kurtosis-3)); featureList.push_back(std::make_pair(params.prefix + "Median", median)); featureList.push_back(std::make_pair(params.prefix + "Minimum", minimum)); - featureList.push_back(std::make_pair(params.prefix + "Percentile 10", p10)); - featureList.push_back(std::make_pair(params.prefix + "Percentile 90", p90)); + featureList.push_back(std::make_pair(params.prefix + "05th Percentile", percentiles[0])); + featureList.push_back(std::make_pair(params.prefix + "10th Percentile", percentiles[1])); + featureList.push_back(std::make_pair(params.prefix + "15th Percentile", percentiles[2])); + featureList.push_back(std::make_pair(params.prefix + "20th Percentile", percentiles[3])); + featureList.push_back(std::make_pair(params.prefix + "25th Percentile", percentiles[4])); + featureList.push_back(std::make_pair(params.prefix + "30th Percentile", percentiles[5])); + featureList.push_back(std::make_pair(params.prefix + "35th Percentile", percentiles[6])); + featureList.push_back(std::make_pair(params.prefix + "40th Percentile", percentiles[7])); + featureList.push_back(std::make_pair(params.prefix + "45th Percentile", percentiles[8])); + featureList.push_back(std::make_pair(params.prefix + "50th Percentile", percentiles[9])); + featureList.push_back(std::make_pair(params.prefix + "55th Percentile", percentiles[10])); + featureList.push_back(std::make_pair(params.prefix + "60th Percentile", percentiles[11])); + featureList.push_back(std::make_pair(params.prefix + "65th Percentile", percentiles[12])); + featureList.push_back(std::make_pair(params.prefix + "70th Percentile", percentiles[13])); + featureList.push_back(std::make_pair(params.prefix + "75th Percentile", percentiles[14])); + featureList.push_back(std::make_pair(params.prefix + "80th Percentile", percentiles[15])); + featureList.push_back(std::make_pair(params.prefix + "85th Percentile", percentiles[16])); + featureList.push_back(std::make_pair(params.prefix + "90th Percentile", percentiles[17])); + featureList.push_back(std::make_pair(params.prefix + "95th Percentile", percentiles[18])); featureList.push_back(std::make_pair(params.prefix + "Maximum", maximum)); featureList.push_back(std::make_pair(params.prefix + "Interquantile range", interquantileRange)); featureList.push_back(std::make_pair(params.prefix + "Range", maximum-minimum)); featureList.push_back(std::make_pair(params.prefix + "Mean absolute deviation", meanAbsoluteDeviation)); featureList.push_back(std::make_pair(params.prefix + "Robust mean absolute deviation", robustMeanAbsoluteDeviation)); featureList.push_back(std::make_pair(params.prefix + "Median absolute deviation", medianAbsoluteDeviation)); featureList.push_back(std::make_pair(params.prefix + "Coefficient of variation", coefficientOfVariation)); featureList.push_back(std::make_pair(params.prefix + "Quantile coefficient of dispersion", quantileCoefficientOfDispersion)); featureList.push_back(std::make_pair(params.prefix + "Energy", energy)); featureList.push_back(std::make_pair(params.prefix + "Root mean square", rootMeanSquare)); featureList.push_back(std::make_pair(params.prefix + "Standard Deviation", std::sqrt(variance))); featureList.push_back(std::make_pair(params.prefix + "Kurtosis", kurtosis)); featureList.push_back(std::make_pair(params.prefix + "Robust mean", robustMean)); featureList.push_back(std::make_pair(params.prefix + "Robust variance", robustVariance)); + featureList.push_back(std::make_pair(params.prefix + "Covered image intensity range", coveredImageRange)); featureList.push_back(std::make_pair(params.prefix + "Mode index", modeIdx)); featureList.push_back(std::make_pair(params.prefix + "Mode value", params.quantifier->IndexToMeanIntensity(modeIdx))); + featureList.push_back(std::make_pair(params.prefix + "Mode probability", histogram[modeIdx] / (1.0*numberOfVoxels))); + featureList.push_back(std::make_pair(params.prefix + "Entropy", entropy)); + featureList.push_back(std::make_pair(params.prefix + "Uniformtiy", uniformity)); featureList.push_back(std::make_pair(params.prefix + "Number of voxels", numberOfVoxels)); + featureList.push_back(std::make_pair(params.prefix + "Sum of voxels", sum)); + featureList.push_back(std::make_pair(params.prefix + "Voxel space", voxelSpace)); + featureList.push_back(std::make_pair(params.prefix + "Voxel volume", voxelVolume)); + featureList.push_back(std::make_pair(params.prefix + "Image Dimension", VImageDimension)); return; - - - - - - - /* - - typedef itk::LabelStatisticsImageFilter FilterType; - typedef typename FilterType::HistogramType HistogramType; - typedef typename HistogramType::IndexType HIndexType; - typedef itk::MinimumMaximumImageCalculator MinMaxComputerType; - - - - - typename MinMaxComputerType::Pointer minMaxComputer = MinMaxComputerType::New(); - minMaxComputer->SetImage(itkImage); - minMaxComputer->Compute(); - double imageRange = minMaxComputer->GetMaximum() - minMaxComputer->GetMinimum(); - - typename FilterType::Pointer labelStatisticsImageFilter = FilterType::New(); - labelStatisticsImageFilter->SetInput( itkImage ); - labelStatisticsImageFilter->SetLabelInput(maskImage); - labelStatisticsImageFilter->SetUseHistograms(true); - - double min = params.MinimumIntensity; - double max = params.MaximumIntensity; - - labelStatisticsImageFilter->SetHistogramParameters(params.Bins, min,max); - labelStatisticsImageFilter->Update(); - - // --------------- Range -------------------- - double range = labelStatisticsImageFilter->GetMaximum(1) - labelStatisticsImageFilter->GetMinimum(1); - // --------------- Uniformity, Entropy -------------------- - double count = labelStatisticsImageFilter->GetCount(1); - //double std_dev = labelStatisticsImageFilter->GetSigma(1); - double mean = labelStatisticsImageFilter->GetMean(1); - double median = labelStatisticsImageFilter->GetMedian(1); - auto histogram = labelStatisticsImageFilter->GetHistogram(1); - bool histogramIsCalculated = histogram; - - HIndexType index; - index.SetSize(1); - - double uniformity = 0; - double entropy = 0; - double squared_sum = 0; - double kurtosis = 0; - double mean_absolut_deviation = 0; - double median_absolut_deviation = 0; - double skewness = 0; - double sum_prob = 0; - double binWidth = 0; - double p05th = 0, p10th = 0, p15th = 0, p20th = 0, p25th = 0, p30th = 0, p35th = 0, p40th = 0, p45th = 0, p50th = 0; - double p55th = 0, p60th = 0, p65th = 0, p70th = 0, p75th = 0, p80th = 0, p85th = 0, p90th = 0, p95th = 0; - - double voxelValue = 0; - - if (histogramIsCalculated) - { - binWidth = histogram->GetBinMax(0, 0) - histogram->GetBinMin(0, 0); - p05th = histogram->Quantile(0, 0.05); - p10th = histogram->Quantile(0, 0.10); - p15th = histogram->Quantile(0, 0.15); - p20th = histogram->Quantile(0, 0.20); - p25th = histogram->Quantile(0, 0.25); - p30th = histogram->Quantile(0, 0.30); - p35th = histogram->Quantile(0, 0.35); - p40th = histogram->Quantile(0, 0.40); - p45th = histogram->Quantile(0, 0.45); - p50th = histogram->Quantile(0, 0.50); - p55th = histogram->Quantile(0, 0.55); - p60th = histogram->Quantile(0, 0.60); - p65th = histogram->Quantile(0, 0.65); - p70th = histogram->Quantile(0, 0.70); - p75th = histogram->Quantile(0, 0.75); - p80th = histogram->Quantile(0, 0.80); - p85th = histogram->Quantile(0, 0.85); - p90th = histogram->Quantile(0, 0.90); - p95th = histogram->Quantile(0, 0.95); - } - double Log2=log(2); - double mode_bin; - double mode_value = 0; - double variance = 0; - if (histogramIsCalculated) - { - for (int i = 0; i < (int)(histogram->GetSize(0)); ++i) - { - index[0] = i; - double prob = histogram->GetFrequency(index); - - - if (prob < 0.00000001) - continue; - - voxelValue = histogram->GetBinMin(0, i) + binWidth * 0.5; - - if (prob > mode_value) - { - mode_value = prob; - mode_bin = voxelValue; - } - - sum_prob += prob; - squared_sum += prob * voxelValue*voxelValue; - - prob /= count; - mean_absolut_deviation += prob* std::abs(voxelValue - mean); - median_absolut_deviation += prob* std::abs(voxelValue - median); - variance += prob * (voxelValue - mean) * (voxelValue - mean); - - kurtosis += prob* (voxelValue - mean) * (voxelValue - mean) * (voxelValue - mean) * (voxelValue - mean); - skewness += prob* (voxelValue - mean) * (voxelValue - mean) * (voxelValue - mean); - - uniformity += prob*prob; - if (prob > 0) - { - entropy += prob * std::log(prob) / Log2; - } - } - } - entropy = -entropy; - - double uncorrected_std_dev = std::sqrt(variance); - double rms = std::sqrt(squared_sum / count); - kurtosis = kurtosis / (variance * variance); - skewness = skewness / (variance * uncorrected_std_dev); - double coveredGrayValueRange = range / imageRange; - double coefficient_of_variation = (mean == 0) ? 0 : std::sqrt(variance) / mean; - double quantile_coefficient_of_dispersion = (p75th - p25th) / (p75th + p25th); - - //Calculate the robust mean absolute deviation - //First, set all frequencies to 0 that are <10th or >90th percentile - double meanRobust = 0.0; - double robustMeanAbsoluteDeviation = 0.0; - if (histogramIsCalculated) - { - for (int i = 0; i < (int)(histogram->GetSize(0)); ++i) - { - index[0] = i; - if (histogram->GetBinMax(0, i) < p10th) - { - histogram->SetFrequencyOfIndex(index, 0); - } - else if (histogram->GetBinMin(0, i) > p90th) - { - histogram->SetFrequencyOfIndex(index, 0); - } - } - - //Calculate the mean - for (int i = 0; i < (int)(histogram->GetSize(0)); ++i) - { - index[0] = i; - meanRobust += histogram->GetFrequency(index) * 0.5 * (histogram->GetBinMin(0, i) + histogram->GetBinMax(0, i)); - } - meanRobust = meanRobust / histogram->GetTotalFrequency(); - for (int i = 0; i < (int)(histogram->GetSize(0)); ++i) - { - index[0] = i; - robustMeanAbsoluteDeviation += std::abs(histogram->GetFrequency(index) * - ((0.5 * (histogram->GetBinMin(0, i) + histogram->GetBinMax(0, i))) - - meanRobust - )); - } - robustMeanAbsoluteDeviation = robustMeanAbsoluteDeviation / histogram->GetTotalFrequency(); - } - - featureList.push_back(std::make_pair(params.prefix + "Mean", labelStatisticsImageFilter->GetMean(1))); - featureList.push_back(std::make_pair(params.prefix + "Unbiased Variance", labelStatisticsImageFilter->GetVariance(1))); //Siehe Definition von Unbiased Variance estimation. (Wird nicht durch n sondern durch n-1 normalisiert) - featureList.push_back(std::make_pair(params.prefix + "Biased Variance", variance)); - featureList.push_back(std::make_pair(params.prefix + "Skewness", skewness)); - featureList.push_back(std::make_pair(params.prefix + "Kurtosis", kurtosis)); - featureList.push_back(std::make_pair(params.prefix + "Median", labelStatisticsImageFilter->GetMedian(1))); - featureList.push_back(std::make_pair(params.prefix + "Minimum", labelStatisticsImageFilter->GetMinimum(1))); - featureList.push_back(std::make_pair(params.prefix + "Maximum", labelStatisticsImageFilter->GetMaximum(1))); - featureList.push_back(std::make_pair(params.prefix + "Range", range)); - featureList.push_back(std::make_pair(params.prefix + "Mean Absolute Deviation", mean_absolut_deviation)); - featureList.push_back(std::make_pair(params.prefix + "Robust Mean Absolute Deviation", robustMeanAbsoluteDeviation)); - featureList.push_back(std::make_pair(params.prefix + "Median Absolute Deviation", median_absolut_deviation)); - featureList.push_back(std::make_pair(params.prefix + "Coefficient Of Variation", coefficient_of_variation)); - featureList.push_back(std::make_pair(params.prefix + "Quantile Coefficient Of Dispersion", quantile_coefficient_of_dispersion)); - featureList.push_back(std::make_pair(params.prefix + "Energy", squared_sum)); - featureList.push_back(std::make_pair(params.prefix + "Root Mean Square", rms)); - - typename HistogramType::MeasurementVectorType mv(1); - mv[0] = 0; - typename HistogramType::IndexType resultingIndex; - histogram->GetIndex(mv, resultingIndex); - featureList.push_back(std::make_pair(params.prefix + "Robust Mean", meanRobust)); - featureList.push_back(std::make_pair(params.prefix + "Uniformity", uniformity)); - featureList.push_back(std::make_pair(params.prefix + "Entropy", entropy)); - featureList.push_back(std::make_pair(params.prefix + "Excess Kurtosis", kurtosis - 3)); - featureList.push_back(std::make_pair(params.prefix + "Covered Image Intensity Range", coveredGrayValueRange)); - featureList.push_back(std::make_pair(params.prefix + "Sum", labelStatisticsImageFilter->GetSum(1))); - featureList.push_back(std::make_pair(params.prefix + "Mode", mode_bin)); - featureList.push_back(std::make_pair(params.prefix + "Mode Probability", mode_value)); - featureList.push_back(std::make_pair(params.prefix + "Unbiased Standard deviation", labelStatisticsImageFilter->GetSigma(1))); - featureList.push_back(std::make_pair(params.prefix + "Biased Standard deviation", sqrt(variance))); - featureList.push_back(std::make_pair(params.prefix + "Number Of Voxels", labelStatisticsImageFilter->GetCount(1))); - - featureList.push_back(std::make_pair(params.prefix + "05th Percentile", p05th)); - featureList.push_back(std::make_pair(params.prefix + "10th Percentile", p10th)); - featureList.push_back(std::make_pair(params.prefix + "15th Percentile", p15th)); - featureList.push_back(std::make_pair(params.prefix + "20th Percentile", p20th)); - featureList.push_back(std::make_pair(params.prefix + "25th Percentile", p25th)); - featureList.push_back(std::make_pair(params.prefix + "30th Percentile", p30th)); - featureList.push_back(std::make_pair(params.prefix + "35th Percentile", p35th)); - featureList.push_back(std::make_pair(params.prefix + "40th Percentile", p40th)); - featureList.push_back(std::make_pair(params.prefix + "45th Percentile", p45th)); - featureList.push_back(std::make_pair(params.prefix + "50th Percentile", p50th)); - featureList.push_back(std::make_pair(params.prefix + "55th Percentile", p55th)); - featureList.push_back(std::make_pair(params.prefix + "60th Percentile", p60th)); - featureList.push_back(std::make_pair(params.prefix + "65th Percentile", p65th)); - featureList.push_back(std::make_pair(params.prefix + "70th Percentile", p70th)); - featureList.push_back(std::make_pair(params.prefix + "75th Percentile", p75th)); - featureList.push_back(std::make_pair(params.prefix + "80th Percentile", p80th)); - featureList.push_back(std::make_pair(params.prefix + "85th Percentile", p85th)); - featureList.push_back(std::make_pair(params.prefix + "90th Percentile", p90th)); - featureList.push_back(std::make_pair(params.prefix + "95th Percentile", p95th)); - featureList.push_back(std::make_pair(params.prefix + "Interquartile Range", (p75th - p25th))); - featureList.push_back(std::make_pair(params.prefix + "Image Dimension", VImageDimension)); - featureList.push_back(std::make_pair(params.prefix + "Voxel Space", voxelSpace)); - featureList.push_back(std::make_pair(params.prefix + "Voxel Volume", voxelVolume)); */ } mitk::GIFFirstOrderNumericStatistics::GIFFirstOrderNumericStatistics() { SetShortName("fon"); SetLongName("first-order-numeric"); SetFeatureClassName("First Order Numeric"); } mitk::GIFFirstOrderNumericStatistics::FeatureListType mitk::GIFFirstOrderNumericStatistics::CalculateFeatures(const Image::Pointer & image, const Image::Pointer &mask) { InitializeQuantifier(image, mask); FeatureListType featureList; FirstOrderNumericParameterStruct params; params.quantifier = GetQuantifier(); params.MinimumIntensity = GetQuantifier()->GetMinimum(); params.MaximumIntensity = GetQuantifier()->GetMaximum(); params.Bins = GetQuantifier()->GetBins(); params.prefix = FeatureDescriptionPrefix(); AccessByItk_3(image, CalculateFirstOrderStatistics, mask, featureList, params); return featureList; } mitk::GIFFirstOrderNumericStatistics::FeatureNameListType mitk::GIFFirstOrderNumericStatistics::GetFeatureNames() { FeatureNameListType featureList; return featureList; } void mitk::GIFFirstOrderNumericStatistics::AddArguments(mitkCommandLineParser &parser) { std::string name = GetOptionPrefix(); parser.addArgument(GetLongName(), name, mitkCommandLineParser::Bool, "Use First Order Statistic (Numeric)", "calculates First Order Statistic (Numeric)", us::Any()); AddQuantifierArguments(parser); } void mitk::GIFFirstOrderNumericStatistics::CalculateFeaturesUsingParameters(const Image::Pointer & feature, const Image::Pointer &, const Image::Pointer &maskNoNAN, FeatureListType &featureList) { auto parsedArgs = GetParameter(); if (parsedArgs.count(GetLongName())) { InitializeQuantifierFromParameters(feature, maskNoNAN); MITK_INFO << "Start calculating first order features ...."; auto localResults = this->CalculateFeatures(feature, maskNoNAN); featureList.insert(featureList.end(), localResults.begin(), localResults.end()); MITK_INFO << "Finished calculating first order features...."; } } std::string mitk::GIFFirstOrderNumericStatistics::GetCurrentFeatureEncoding() { return QuantifierParameterString(); } \ No newline at end of file