RandError (Fiji Javadocs 0-SNAPSHOT API)

java.lang.Object
- trainableSegmentation.metrics.Metrics
- - trainableSegmentation.metrics.RandError

public class RandError
extends Metrics

This class implements the Rand error metric. The Rand error is defined as the 1 - Rand index. We follow the definition of Rand index as described by William M. Rand \cite{Rand71}. Two implementations are given, the classic one, and a foreground-restricted version that prunes out the background pixels of the ground truth during the metric calculation. BibTeX:

 @article{Rand71,
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }

Field Summary
- Fields inherited from class trainableSegmentation.metrics.Metrics
  originalLabels, proposedLabels, verbose

Constructor Summary

Constructors
Constructor and Description

RandError(ij.ImagePlus originalLabels, ij.ImagePlus proposedLabels)
Initialize Rand error metric

Constructors
Constructor and Description
`RandError(ij.ImagePlus originalLabels, ij.ImagePlus proposedLabels)` Initialize Rand error metric

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static double`	`adaptedRandIndex3D(ij.ImagePlus originalLabels, ij.ImagePlus proposedLabels)` Calculate the Rand index between to 3D clusters, as described by William M.
`static double`	`adaptedRandIndexFScore3D(ij.ImagePlus originalLabels, ij.ImagePlus proposedLabels)` Calculate the F-score of the Rand index between to 3D clusters, as described by William M.
`static ClassificationStatistics`	`adaptedRandIndexStats3D(ij.ImagePlus originalLabels, ij.ImagePlus proposedLabels)` Calculate the Rand index between to 3D clusters, as described by William M.
`static double[]`	`adaptedRandIndexStats3DN2(ij.ImagePlus segA, ij.ImagePlus segB)` Calculate the Rand index stats between to 3D clusters, as described by William M.
`double`	`classicRandIndex(ij.process.ShortProcessor cluster1, ij.process.ShortProcessor cluster2)` Calculate the Rand index between to clusters, as described by William M.
`double`	`foregroundRestrictedRandError(ij.process.ImageProcessor label, ij.process.ImageProcessor proposal, double binaryThreshold)` Calculate the foreground-restricted Rand error between some 2D original labels and the corresponding proposed labels.
`double`	`foregroundRestrictedRandIndex(ij.process.ShortProcessor cluster1, ij.process.ShortProcessor cluster2)` Calculate the Rand index between to clusters, as described by William M.
`double[]`	`getForegroundRestrictedGroundTruthDisagreements(ij.process.ShortProcessor cluster1, ij.process.ShortProcessor cluster2)` Get foreground-restricted disagreements between prediction and ground truth labels with N^2 normalization (mergers).
`double`	`getForegroundRestrictedMetricValue(double binaryThreshold)` Calculate the foreground-restricted Rand error in 2D between some original labels and the corresponding proposed labels.
`double[]`	`getForegroundRestrictedPredictionDisagreements(ij.process.ShortProcessor cluster1, ij.process.ShortProcessor cluster2)` Get foreground-restricted disagreements between ground truth and prediction labels with N^2 normalization (splits).
`ClassificationStatistics`	`getForegroundRestrictedRandAfterThinningStats(double binaryThreshold, boolean perSliceAverage)` Calculate the foreground-restricted Rand score (N^2 normalization) and its derived statistics in 2D between some original labels and the corresponding proposed labels after border thinning.
`ArrayList<ClassificationStatistics>`	`getForegroundRestrictedRandAfterThinningStats(double minThreshold, double maxThreshold, double stepThreshold, boolean perSliceAverage)` Calculate the precision-recall values based on the foreground-restricted Rand score between some 2D original labels and the corresponding proposed labels (after border thinning).
`Callable<ClassificationStatistics>`	`getForegroundRestrictedRandAfterThinningStatsConcurrent(ij.process.ImageProcessor image1, ij.process.ImageProcessor image2, double binaryThreshold)` Get foreground-restricted Rand score value and derived statistics between two images in a concurrent way (to be submitted to an Executor Service).
`ClassificationStatistics`	`getForegroundRestrictedRandAfterThinningStatsN2(ij.process.ImageProcessor label, ij.process.ImageProcessor proposal, double binaryThreshold)` Calculate the foreground-restricted Rand precision and recall between some 2D original labels and the corresponding proposed labels with N^2 normalization.
`Callable<Double>`	`getForegroundRestrictedRandErrorConcurrent(ij.process.ImageProcessor image1, ij.process.ImageProcessor image2, double binaryThreshold)` Get foreground-restricted Rand error between two images in a concurrent way (to be submitted to an Executor Service).
`double`	`getForegroundRestrictedRandIndexMaximalFScore(double minThreshold, double maxThreshold, double stepThreshold)` Get the best F-score of the foreground-restricted Rand index over a set of thresholds.
`ClassificationStatistics`	`getForegroundRestrictedRandIndexStats(double binaryThreshold)` Calculate the foreground-restricted Rand error (N^2 normalization) and its derived statistics in 2D between some original labels and the corresponding proposed labels.
`ArrayList<ClassificationStatistics>`	`getForegroundRestrictedRandIndexStats(double minThreshold, double maxThreshold, double stepThreshold)` Calculate the precision-recall values based on the foreground-restricted Rand index between some 2D original labels and the corresponding proposed labels.
`Callable<ClassificationStatistics>`	`getForegroundRestrictedRandIndexStatsConcurrent(ij.process.ImageProcessor image1, ij.process.ImageProcessor image2, double binaryThreshold)` Get foreground-restricted Rand index value and derived statistics between two images in a concurrent way (to be submitted to an Executor Service).
`ClassificationStatistics`	`getForegroundRestrictedRandIndexStatsN2(ij.process.ImageProcessor label, ij.process.ImageProcessor proposal, double binaryThreshold)` Calculate the foreground-restricted Rand precision and recall between some 2D original labels and the corresponding proposed labels with N^2 normalization.
`ClassificationStatistics`	`getForegroundRestrictedRandIndexStatsN2(ij.process.ShortProcessor cluster1, ij.process.ShortProcessor cluster2)` Get foreground-restricted Rand statistics (precision and recall) with N^2 normalization.
`ClassificationStatistics[]`	`getForegroundRestrictedRandIndexStatsPerSlice(double binaryThreshold)` Calculate the foreground-restricted Rand index (N^2 normalization) and its derived statistics in 2D between some original labels and the corresponding proposed labels.
`double`	`getMaximalVRandAfterThinning(double minThreshold, double maxThreshold, double stepThreshold, boolean perSliceAverage)` Get the best V_Rand after thinning over a set of thresholds.
`double`	`getMetricValue(double binaryThreshold)` Calculate the Rand error in 2D between some original labels and the corresponding proposed labels.
`Callable<Double>`	`getRandErrorConcurrent(ij.process.ImageProcessor image1, ij.process.ImageProcessor image2, double binaryThreshold)` Get standard Rand error between two images in a concurrent way (to be submitted to an Executor Service).
`double`	`getRandIndexMaximalFScore(double minThreshold, double maxThreshold, double stepThreshold)` Get the best F-score of the standard Rand index over a set of thresholds.
`ClassificationStatistics`	`getRandIndexStats(double binaryThreshold)` Calculate the standard Rand index and its derived statistics in 2D between some original labels and the corresponding proposed labels.
`ArrayList<ClassificationStatistics>`	`getRandIndexStats(double minThreshold, double maxThreshold, double stepThreshold)` Calculate the precision-recall values based on standard Rand index between some 2D original labels and the corresponding proposed labels.
`ClassificationStatistics`	`getRandIndexStats(ij.process.ShortProcessor cluster1, ij.process.ShortProcessor cluster2)` Calculate the standard Rand index between to clusters, as described by William M.
`Callable<ClassificationStatistics>`	`getRandIndexStatsConcurrent(ij.process.ImageProcessor image1, ij.process.ImageProcessor image2, double binaryThreshold)` Get standard Rand index value and derived statistics between two images in a concurrent way (to be submitted to an Executor Service).
`static void`	`main(String[] args)` Main method for calculating the Rand error metrics from the command line
`double`	`randError(ij.process.ImageProcessor label, ij.process.ImageProcessor proposal, double binaryThreshold)` Calculate the standard Rand error between some 2D original labels and the corresponding proposed labels.
`ClassificationStatistics`	`randIndexStats(ij.process.ImageProcessor label, ij.process.ImageProcessor proposal, double binaryThreshold)` Calculate the standard Rand index between some 2D original labels and the corresponding proposed labels.
`void`	`setVerboseMode(boolean verbose)` Set verbose mode

Methods inherited from class trainableSegmentation.metrics.Metrics
getMinimumMetricValue

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - RandError
```
public RandError(ij.ImagePlus originalLabels,
                 ij.ImagePlus proposedLabels)
```
    Initialize Rand error metric
    
    Parameters:
    
    originalLabels - original labels (single 2D image or stack)
    
    proposedLabels - proposed new labels (single 2D image or stack of the same as as the original labels)
- Method Detail
  - getMetricValue
```
public double getMetricValue(double binaryThreshold)
```
    Calculate the Rand error in 2D between some original labels and the corresponding proposed labels. Both image are binarized. The Rand error is defined as the 1 - Rand index, as described by William M. Rand \cite{Rand71}. Note: background pixels are considered part of the same object. If more than one slice is provided, the error is averaged per slice. BibTeX:
```
 @article{Rand71,
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }
 
```
    Specified by:
    
    getMetricValue in class Metrics
    
    Parameters:
    
    binaryThreshold - threshold value to binarize proposal (larger than 0 and smaller than 1)
    
    Returns:
    
    average Rand error (defined as 1.0 - classic Rand index) per slice
  - getForegroundRestrictedMetricValue
```
public double getForegroundRestrictedMetricValue(double binaryThreshold)
```
    Calculate the foreground-restricted Rand error in 2D between some original labels and the corresponding proposed labels. Both image are binarized.The foreground-restricted Rand error is defined as 1.0 - foreground-restricted Rand index. Note: the background pixels of the ground-truth are pruned out. If more than one slice is provided, the error is averaged per slice.
    
    Parameters:
    
    binaryThreshold - threshold value to binarize proposal (larger than 0 and smaller than 1)
    
    Returns:
    
    average foreground-restricted Rand error
  - getRandIndexStats
```
public ClassificationStatistics getRandIndexStats(double binaryThreshold)
```
    Calculate the standard Rand index and its derived statistics in 2D between some original labels and the corresponding proposed labels. Both images are binarized. We follow the definition of Rand index described by William M. Rand \cite{Rand71}. NOTE: the Rand index is averaged over the slices, but the F-score is calculated using the total number of positive and negative samples (it is not an averaged F-score). BibTeX:
```
 @article{Rand71,
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }
 
```
    Parameters:
    
    binaryThreshold - threshold value to binarize proposal (larger than 0 and smaller than 1)
    
    Returns:
    
    standard Rand index value and derived statistics
  - getForegroundRestrictedRandIndexStats
```
public ClassificationStatistics getForegroundRestrictedRandIndexStats(double binaryThreshold)
```
    Calculate the foreground-restricted Rand error (N^2 normalization) and its derived statistics in 2D between some original labels and the corresponding proposed labels. Both images are binarized. NOTE: the metric value returned in the classification statistics is the foreground-restricted Rand index averaged per slice.
    
    Parameters:
    
    binaryThreshold - threshold value to binarize proposal (larger than 0 and smaller than 1)
    
    Returns:
    
    foreground-restricted Rand index value and derived statistics
  - getForegroundRestrictedRandAfterThinningStats
```
public ClassificationStatistics getForegroundRestrictedRandAfterThinningStats(double binaryThreshold,
                                                                              boolean perSliceAverage)
```
    Calculate the foreground-restricted Rand score (N^2 normalization) and its derived statistics in 2D between some original labels and the corresponding proposed labels after border thinning. Both images are binarized. NOTE: the metric value returned in the classification statistics is the foreground-restricted Rand index averaged per slice.
    
    Parameters:
    
    binaryThreshold - threshold value to binarize proposal (larger than 0 and smaller than 1)
    
    perSliceAverage - flag to return F-score value averaged per slice (macro-averaged F-score)
    
    Returns:
    
    foreground-restricted Rand index value and derived statistics after thinning
  - getForegroundRestrictedRandIndexStatsPerSlice
```
public ClassificationStatistics[] getForegroundRestrictedRandIndexStatsPerSlice(double binaryThreshold)
```
    Calculate the foreground-restricted Rand index (N^2 normalization) and its derived statistics in 2D between some original labels and the corresponding proposed labels. Both images are binarized. Individual results are given per each slice.
    
    Parameters:
    
    binaryThreshold - threshold value to binarize proposal ([0 1])
    
    Returns:
    
    foreground-restricted Rand index value and derived statistics per slice.
  - getRandIndexStats
```
public ArrayList<ClassificationStatistics> getRandIndexStats(double minThreshold,
                                                             double maxThreshold,
                                                             double stepThreshold)
```
    Calculate the precision-recall values based on standard Rand index between some 2D original labels and the corresponding proposed labels. We follow the definition of Rand index as described by William M. Rand \cite{Rand71}. BibTeX:
```
 @article{Rand71,label
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }
 
```
    Parameters:
    
    minThreshold - minimum threshold value to binarize the input images
    
    maxThreshold - maximum threshold value to binarize the input images
    
    stepThreshold - threshold step value to use during binarization
    
    Returns:
    
    standard Rand index value and derived statistics for each threshold
  - getForegroundRestrictedRandIndexStats
```
public ArrayList<ClassificationStatistics> getForegroundRestrictedRandIndexStats(double minThreshold,
                                                                                 double maxThreshold,
                                                                                 double stepThreshold)
```
    Calculate the precision-recall values based on the foreground-restricted Rand index between some 2D original labels and the corresponding proposed labels.
    
    Parameters:
    
    minThreshold - minimum threshold value to binarize the input images
    
    maxThreshold - maximum threshold value to binarize the input images
    
    stepThreshold - threshold step value to use during binarization
    
    Returns:
    
    foreground-restricted Rand index value and derived statistics for each threshold
  - getForegroundRestrictedRandAfterThinningStats
```
public ArrayList<ClassificationStatistics> getForegroundRestrictedRandAfterThinningStats(double minThreshold,
                                                                                         double maxThreshold,
                                                                                         double stepThreshold,
                                                                                         boolean perSliceAverage)
```
    Calculate the precision-recall values based on the foreground-restricted Rand score between some 2D original labels and the corresponding proposed labels (after border thinning).
    
    Parameters:
    
    minThreshold - minimum threshold value to binarize the input images
    
    maxThreshold - maximum threshold value to binarize the input images
    
    stepThreshold - threshold step value to use during binarization
    
    perSliceAverage - flag to return values averaging per slice (macro-average)
    
    Returns:
    
    Rand score value after thinning and derived statistics for each threshold
  - getRandErrorConcurrent
```
public Callable<Double> getRandErrorConcurrent(ij.process.ImageProcessor image1,
                                               ij.process.ImageProcessor image2,
                                               double binaryThreshold)
```
    Get standard Rand error between two images in a concurrent way (to be submitted to an Executor Service). Both images are binarized. The Rand error is defined as the 1 - Rand index, as described by William M. Rand \cite{Rand71}. BibTeX:
```
 @article{Rand71,
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }
 
```
    Parameters:
    
    image1 - first image
    
    image2 - second image
    
    binaryThreshold - threshold to apply to both images
    
    Returns:
    
    standard Rand error (1 - standard Rand index)
  - getForegroundRestrictedRandErrorConcurrent
```
public Callable<Double> getForegroundRestrictedRandErrorConcurrent(ij.process.ImageProcessor image1,
                                                                   ij.process.ImageProcessor image2,
                                                                   double binaryThreshold)
```
    Get foreground-restricted Rand error between two images in a concurrent way (to be submitted to an Executor Service). Both images are binarized.
    
    Parameters:
    
    image1 - ground truth 2D image
    
    image2 - proposal 2D image
    
    binaryThreshold - threshold to apply to both images
    
    Returns:
    
    foreground-restricted Rand error (1 - foreground-restricted Rand index)
  - getRandIndexStatsConcurrent
```
public Callable<ClassificationStatistics> getRandIndexStatsConcurrent(ij.process.ImageProcessor image1,
                                                                      ij.process.ImageProcessor image2,
                                                                      double binaryThreshold)
```
    Get standard Rand index value and derived statistics between two images in a concurrent way (to be submitted to an Executor Service). Both images are binarized. We follow the Rand index definition described by William M. Rand \cite{Rand71}. BibTeX:
```
 @article{Rand71,
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }
 
```
    Parameters:
    
    image1 - first image
    
    image2 - second image
    
    binaryThreshold - threshold to apply to both images
    
    Returns:
    
    standard Rand index value and derived statistics
  - getForegroundRestrictedRandIndexStatsConcurrent
```
public Callable<ClassificationStatistics> getForegroundRestrictedRandIndexStatsConcurrent(ij.process.ImageProcessor image1,
                                                                                          ij.process.ImageProcessor image2,
                                                                                          double binaryThreshold)
```
    Get foreground-restricted Rand index value and derived statistics between two images in a concurrent way (to be submitted to an Executor Service). Both images are binarized.
    
    Parameters:
    
    image1 - ground-truth image
    
    image2 - proposed labels image
    
    binaryThreshold - threshold to apply to both images
    
    Returns:
    
    foreground-restricted Rand index value and derived statistics
  - getForegroundRestrictedRandAfterThinningStatsConcurrent
```
public Callable<ClassificationStatistics> getForegroundRestrictedRandAfterThinningStatsConcurrent(ij.process.ImageProcessor image1,
                                                                                                  ij.process.ImageProcessor image2,
                                                                                                  double binaryThreshold)
```
    Get foreground-restricted Rand score value and derived statistics between two images in a concurrent way (to be submitted to an Executor Service). Both images are binarized and the borders of the second image are thinned to 1-pixel width.
    
    Parameters:
    
    image1 - ground-truth image
    
    image2 - proposed labels image
    
    binaryThreshold - threshold to apply to both images
    
    Returns:
    
    foreground-restricted Rand score after thinning value and derived statistics
  - randError
```
public double randError(ij.process.ImageProcessor label,
                        ij.process.ImageProcessor proposal,
                        double binaryThreshold)
```
    Calculate the standard Rand error between some 2D original labels and the corresponding proposed labels. Both image are binarized. The Rand error is defined as the 1 - Rand index, as described by William M. Rand \cite{Rand71}. BibTeX:
```
 @article{Rand71,
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }
 
```
    Parameters:
    
    label - 2D image with the original labels
    
    proposal - 2D image with the proposed labels
    
    binaryThreshold - threshold value to binarize the input images
    
    Returns:
    
    standard Rand error (1 - standard Rand index)
  - foregroundRestrictedRandError
```
public double foregroundRestrictedRandError(ij.process.ImageProcessor label,
                                            ij.process.ImageProcessor proposal,
                                            double binaryThreshold)
```
    Calculate the foreground-restricted Rand error between some 2D original labels and the corresponding proposed labels. Both image are binarized. The foreground-restricted Rand error is defined as the 1 - Rand index (as described by William M. Rand \cite{Rand71}, but pruining out the zero-component of the ground-truth). BibTeX:
```
 @article{Rand71,
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }
 
```
    Parameters:
    
    label - 2D image with the original labels
    
    proposal - 2D image with the proposed labels
    
    binaryThreshold - threshold value to binarize the input images
    
    Returns:
    
    foreground-restricted Rand error (1 - foreground-restricted Rand index)
  - randIndexStats
```
public ClassificationStatistics randIndexStats(ij.process.ImageProcessor label,
                                               ij.process.ImageProcessor proposal,
                                               double binaryThreshold)
```
    Calculate the standard Rand index between some 2D original labels and the corresponding proposed labels. Both image are binarized. We follow the definition of Rand index as described by William M. Rand \cite{Rand71}. BibTeX:
```
 @article{Rand71,
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }
 
```
    Parameters:
    
    label - 2D image with the original labels
    
    proposal - 2D image with the proposed labels
    
    binaryThreshold - threshold value to binarize the input images
    
    Returns:
    
    standard Rand index value and derived statistics
  - getForegroundRestrictedRandIndexStatsN2
```
public ClassificationStatistics getForegroundRestrictedRandIndexStatsN2(ij.process.ImageProcessor label,
                                                                        ij.process.ImageProcessor proposal,
                                                                        double binaryThreshold)
```
    Calculate the foreground-restricted Rand precision and recall between some 2D original labels and the corresponding proposed labels with N^2 normalization. Both input images are binarized based on the input threshold value. NOTE: the returned metric value is the foreground-restricted Rand index
    
    Parameters:
    
    label - 2D image with the original (ground truth) binary labels
    
    proposal - 2D image with the proposed label probabilities
    
    binaryThreshold - threshold value to binarize the input images
    
    Returns:
    
    foreground-restricted Rand index statistics
  - getForegroundRestrictedRandAfterThinningStatsN2
```
public ClassificationStatistics getForegroundRestrictedRandAfterThinningStatsN2(ij.process.ImageProcessor label,
                                                                                ij.process.ImageProcessor proposal,
                                                                                double binaryThreshold)
```
    Calculate the foreground-restricted Rand precision and recall between some 2D original labels and the corresponding proposed labels with N^2 normalization. Both input images are binarized based on the input threshold value and the proposal labels are thinned to 1-pixel width. NOTE: the returned metric value is the foreground-restricted Rand score
    
    Parameters:
    
    label - 2D image with the original (ground truth) binary labels
    
    proposal - 2D image with the proposed label probabilities
    
    binaryThreshold - threshold value to binarize the input images
    
    Returns:
    
    foreground-restricted Rand score statistics after thinning
  - classicRandIndex
```
public double classicRandIndex(ij.process.ShortProcessor cluster1,
                               ij.process.ShortProcessor cluster2)
```
    Calculate the Rand index between to clusters, as described by William M. Rand \cite{Rand71}. Note that this version of the Rand index treats the zero component (background) as another object. BibTeX:
```
 @article{Rand71,
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }
 
```
    Parameters:
    
    cluster1 - 2D segmented image (objects are labeled with different numbers)
    
    cluster2 - 2D segmented image (objects are labeled with different numbers)
    
    Returns:
    
    Rand index
  - foregroundRestrictedRandIndex
```
public double foregroundRestrictedRandIndex(ij.process.ShortProcessor cluster1,
                                            ij.process.ShortProcessor cluster2)
```
    Calculate the Rand index between to clusters, as described by William M. Rand \cite{Rand71}, but pruning out the zero component in the ground truth (cluster 1). BibTeX:
```
 @article{Rand71,
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }
 
```
    Parameters:
    
    cluster1 - ground truth, 2D segmented image (objects are labeled with different numbers)
    
    cluster2 - prediction, 2D segmented image (objects are labeled with different numbers)
    
    Returns:
    
    foreground-restricted Rand index of the two images
  - adaptedRandIndex3D
```
public static double adaptedRandIndex3D(ij.ImagePlus originalLabels,
                                        ij.ImagePlus proposedLabels)
```
    Calculate the Rand index between to 3D clusters, as described by William M. Rand \cite{Rand71}, but pruning out the zero component of the ground truth, which leads to an asymmetric index. The input images must be 16-bit. Note: this method is based on the N_choose_2 normalization. BibTeX:
```
 @article{Rand71,
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }
 
```
    Parameters:
    
    originalLabels - ground truth, 3D segmented image (objects are labeled with different numbers)
    
    proposedLabels - prediction, 3D segmented image (objects are labeled with different numbers)
    
    Returns:
    
    adapted Rand index value
  - adaptedRandIndexStats3D
```
public static ClassificationStatistics adaptedRandIndexStats3D(ij.ImagePlus originalLabels,
                                                               ij.ImagePlus proposedLabels)
```
    Calculate the Rand index between to 3D clusters, as described by William M. Rand \cite{Rand71}, but pruning out the zero component of the ground truth, which leads to an asymmetric index. The input images must be 16-bit. Note: this method is based on the N_choose_2 normalization. BibTeX:
```
 @article{Rand71,
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }
 
```
    Parameters:
    
    originalLabels - ground truth, 3D segmented image (objects are labeled with different numbers)
    
    proposedLabels - prediction, 3D segmented image (objects are labeled with different numbers)
    
    Returns:
    
    adapted Rand index value and prediction statistics
  - adaptedRandIndexStats3DN2
```
public static double[] adaptedRandIndexStats3DN2(ij.ImagePlus segA,
                                                 ij.ImagePlus segB)
```
    Calculate the Rand index stats between to 3D clusters, as described by William M. Rand \cite{Rand71}, but pruning out the zero component of the ground truth, which leads to an asymmetric index. The input images must be 16-bit. Note: this method is based on the N^2 normalization. BibTeX:
```
 @article{Rand71,
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }
 
```
    Parameters:
    
    segA - ground truth, 3D segmented image (objects are labeled with different numbers)
    
    segB - prediction, 3D segmented image (objects are labeled with different numbers)
    
    Returns:
    
    [ precision, recall, Rand index with n^2 normalization ]
  - adaptedRandIndexFScore3D
```
public static double adaptedRandIndexFScore3D(ij.ImagePlus originalLabels,
                                              ij.ImagePlus proposedLabels)
```
    Calculate the F-score of the Rand index between to 3D clusters, as described by William M. Rand \cite{Rand71}, but pruning out the zero component of the ground truth, which leads to an asymmetric index. The input images must be 16-bit. Note: this method is based on the N^2 normalization. BibTeX:
```
 @article{Rand71,
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }
 
```
    Parameters:
    
    originalLabels - ground truth, 3D segmented image (objects are labeled with different numbers)
    
    proposedLabels - prediction, 3D segmented image (objects are labeled with different numbers)
    
    Returns:
    
    F-score of Rand index in 3D (-1 if error)
  - getRandIndexStats
```
public ClassificationStatistics getRandIndexStats(ij.process.ShortProcessor cluster1,
                                                  ij.process.ShortProcessor cluster2)
```
    Calculate the standard Rand index between to clusters, as described by William M. Rand \cite{Rand71}. BibTeX:
```
 @article{Rand71,
   author    = {William M. Rand},
   title     = {Objective criteria for the evaluation of clustering methods},
   journal   = {Journal of the American Statistical Association},
   year      = {1971},
   volume    = {66},
   number    = {336},
   pages     = {846--850},
   doi       = {10.2307/2284239)
 }
 
```
    Parameters:
    
    cluster1 - ground truth, 2D segmented image (objects are labeled with different numbers)
    
    cluster2 - prediction, 2D segmented image (objects are labeled with different numbers)
    
    Returns:
    
    Rand index value and prediction statistics
  - getForegroundRestrictedRandIndexStatsN2
```
public ClassificationStatistics getForegroundRestrictedRandIndexStatsN2(ij.process.ShortProcessor cluster1,
                                                                        ij.process.ShortProcessor cluster2)
```
    Get foreground-restricted Rand statistics (precision and recall) with N^2 normalization.
    
    Parameters:
    
    cluster1 - ground truth cluster
    
    cluster2 - proposed cluster
    
    Returns:
    
    foreground-restiricted statistics (Rand index, precision, etc)
  - getForegroundRestrictedGroundTruthDisagreements
```
public double[] getForegroundRestrictedGroundTruthDisagreements(ij.process.ShortProcessor cluster1,
                                                                ij.process.ShortProcessor cluster2)
```
    Get foreground-restricted disagreements between prediction and ground truth labels with N^2 normalization (mergers).
    
    Parameters:
    
    cluster1 - ground truth cluster
    
    cluster2 - proposed cluster
    
    Returns:
    
    normalized foreground-restricted mergers per label
  - getForegroundRestrictedPredictionDisagreements
```
public double[] getForegroundRestrictedPredictionDisagreements(ij.process.ShortProcessor cluster1,
                                                               ij.process.ShortProcessor cluster2)
```
    Get foreground-restricted disagreements between ground truth and prediction labels with N^2 normalization (splits).
    
    Parameters:
    
    cluster1 - ground truth cluster
    
    cluster2 - proposed cluster
    
    Returns:
    
    normalized foreground-restricted splits per label
  - getRandIndexMaximalFScore
```
public double getRandIndexMaximalFScore(double minThreshold,
                                        double maxThreshold,
                                        double stepThreshold)
```
    Get the best F-score of the standard Rand index over a set of thresholds. Note: background pixels are considered part of the same object.
    
    Parameters:
    
    minThreshold - minimum threshold value to binarize the input images
    
    maxThreshold - maximum threshold value to binarize the input images
    
    stepThreshold - threshold step value to use during binarization
    
    Returns:
    
    maximal F-score of the standard Rand index
  - getForegroundRestrictedRandIndexMaximalFScore
```
public double getForegroundRestrictedRandIndexMaximalFScore(double minThreshold,
                                                            double maxThreshold,
                                                            double stepThreshold)
```
    Get the best F-score of the foreground-restricted Rand index over a set of thresholds. Note: the background pixels of the ground truth are pruned out in the calculations.
    
    Parameters:
    
    minThreshold - minimum threshold value to binarize the input images
    
    maxThreshold - maximum threshold value to binarize the input images
    
    stepThreshold - threshold step value to use during binarization
    
    Returns:
    
    maximal F-score of the standard Rand index
  - getMaximalVRandAfterThinning
```
public double getMaximalVRandAfterThinning(double minThreshold,
                                           double maxThreshold,
                                           double stepThreshold,
                                           boolean perSliceAverage)
```
    Get the best V_Rand after thinning over a set of thresholds. Note: the background pixels of the ground truth are pruned out in the calculations and the background pixels of the proposal are thinned to a 1-pixel width line using the classic watershed algorithm. A flag is used to apply the macro- or micro-averaged score. Note: In the micro-average method, you sum up the individual true positives, false positives, and false negatives of the classification of different slices and the apply them to get the statistics. In the macro-average method we take the average of the score on the different slices.
    
    Parameters:
    
    minThreshold - minimum threshold value to binarize the input images
    
    maxThreshold - maximum threshold value to binarize the input images
    
    stepThreshold - threshold step value to use during binarization
    
    perSliceAverage - flag to calculate macro- or micro-averaged Rand score
    
    Returns:
    
    maximal V_Rand after thinning
  - main
```
public static void main(String[] args)
```
    Main method for calculating the Rand error metrics from the command line
    
    Parameters:
    
    args - arguments to decide the action
  - setVerboseMode
```
public void setVerboseMode(boolean verbose)
```
    Set verbose mode
    
    Overrides:
    
    setVerboseMode in class Metrics
    
    Parameters:
    
    verbose - true to display more information in the standard output

Class RandError

Field Summary

Fields inherited from class trainableSegmentation.metrics.Metrics

Constructor Summary

Method Summary

Methods inherited from class trainableSegmentation.metrics.Metrics

Methods inherited from class java.lang.Object

Constructor Detail

RandError

Method Detail

getMetricValue

getForegroundRestrictedMetricValue

getRandIndexStats

getForegroundRestrictedRandIndexStats

getForegroundRestrictedRandAfterThinningStats

getForegroundRestrictedRandIndexStatsPerSlice

getRandIndexStats

getForegroundRestrictedRandIndexStats

getForegroundRestrictedRandAfterThinningStats

getRandErrorConcurrent

getForegroundRestrictedRandErrorConcurrent

getRandIndexStatsConcurrent

getForegroundRestrictedRandIndexStatsConcurrent

getForegroundRestrictedRandAfterThinningStatsConcurrent

randError

foregroundRestrictedRandError

randIndexStats

getForegroundRestrictedRandIndexStatsN2

getForegroundRestrictedRandAfterThinningStatsN2

classicRandIndex

foregroundRestrictedRandIndex

adaptedRandIndex3D

adaptedRandIndexStats3D

adaptedRandIndexStats3DN2

adaptedRandIndexFScore3D

getRandIndexStats

getForegroundRestrictedRandIndexStatsN2

getForegroundRestrictedGroundTruthDisagreements

getForegroundRestrictedPredictionDisagreements

getRandIndexMaximalFScore

getForegroundRestrictedRandIndexMaximalFScore

getMaximalVRandAfterThinning

main

setVerboseMode