VariationOfInformation (Fiji Javadocs 0-SNAPSHOT API)

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

```
public class VariationOfInformation
extends Metrics
```
This class implements the variation of information metric, used to compare clusters or segmentations. 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.

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

Constructor Summary

Constructors
Constructor and Description

VariationOfInformation(ij.ImagePlus originalLabels, ij.ImagePlus proposedLabels)
Initialize variation of information metric

Constructors
Constructor and Description
`VariationOfInformation(ij.ImagePlus originalLabels, ij.ImagePlus proposedLabels)` Initialize variation of information metric

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`double`	`foregroundRestrictedFscore(ij.process.ShortProcessor cluster1, ij.process.ShortProcessor cluster2)` Calculate the F-score of the variation of information between two clusters using the foreground restriction, i.e.
`double`	`foregroundRestrictedFScoreN2(ij.process.ImageProcessor label, ij.process.ImageProcessor proposal, double binaryThreshold)` Calculate F-score of foreground-restricted variation of information with N^2 normalization
`double`	`foregroundRestrictedScoreAfterThinningN2(ij.process.ImageProcessor label, ij.process.ImageProcessor proposal, double binaryThreshold)` Calculate foreground-restricted information theoretic score with N^2 normalization after border thinning
`InformationStatistics`	`foregroundRestrictedStats(ij.process.ImageProcessor gt, ij.process.ImageProcessor proposal, double binaryThreshold)` Get the foreground-restricted variation of information statistics (entropy values, F-score, etc)
`InformationStatistics`	`foregroundRestrictedStats(ij.process.ShortProcessor cluster1, ij.process.ShortProcessor cluster2)` Calculate the variation of information statistics (entropy values, F-score, etc) between two clusters using the foreground restriction, i.e.
`double`	`foregroundRestrictedVI(ij.process.ShortProcessor cluster1, ij.process.ShortProcessor cluster2)` Calculate the variation of information between two clusters using the foreground restriction, i.e.
`double`	`foregroundRestrictedVIN2(ij.process.ImageProcessor label, ij.process.ImageProcessor proposal, double binaryThreshold)` Calculate foreground-restricted variation of information with N^2 normalization
`double`	`fscore(ij.process.ShortProcessor cluster1, ij.process.ShortProcessor cluster2)` Calculate the F-score of the variation of information between two clusters A and B ( harmonic mean of C(A\|B) and C(B\|A) )
`double`	`fScoreN2(ij.process.ImageProcessor label, ij.process.ImageProcessor proposal, double binaryThreshold)` Calculate F-score of variation of information with N^2 normalization
`double`	`getForegroundRestrictedFscore(double th)` Get F-score of the foreground-restricted variation of information for a given threshold of the proposal labels.
`Callable<Double>`	`getforegroundRestrictedFscoreConcurrent(ij.process.ImageProcessor image1, ij.process.ImageProcessor image2, double binaryThreshold)` Get F-score of the foreground-restricted variation of information in a concurrent way.
`ArrayList<Double>`	`getForegroundRestrictedFscores(double minThreshold, double maxThreshold, double stepThreshold)` Get foreground-restricted F-score of the variation of information over a set of thresholds
`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`	`getForegroundRestrictedMaximalFScore(double minThreshold, double maxThreshold, double stepThreshold)` Get the best F-score of the foreground-restricted variation of information over a set of thresholds
`double`	`getForegroundRestrictedMetricValue(double binaryThreshold)` Get foreground-restricted variation of information between original and proposed labels for a given threshold
`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).
`double`	`getForegroundRestrictedScoreAfterThinning(double th)` Get foreground-restricted information theoretic score after border thinning for a given threshold of the proposal labels.
`Callable<Double>`	`getforegroundRestrictedScoreAfterThinningConcurrent(ij.process.ImageProcessor image1, ij.process.ImageProcessor image2, double binaryThreshold)` Get foreground-restricted information theoretic score after border thinning in a concurrent way.
`ArrayList<Double>`	`getForegroundRestrictedScoresAfterThinning(double minThreshold, double maxThreshold, double stepThreshold)` Get foreground-restricted information theoretic score after thinning over a set of thresholds
`InformationStatistics[]`	`getForegroundRestrictedStatsPerSlice(double binaryThreshold)` Get the foreground-restricted variation of information statistics (entropy values, F-score, etc) per slice and for a given threshold value.
`Callable<Double>`	`getForegroundRestrictedVIConcurrent(ij.process.ImageProcessor image1, ij.process.ImageProcessor image2, double binaryThreshold)` Calculate foreground-restricted variation of information between two images in a concurrent way (to be submitted to an Executor Service).
`double`	`getFscore(double th)` Get F-score of the variation of information for a given threshold of the proposal labels.
`Callable<Double>`	`getFscoreConcurrent(ij.process.ImageProcessor image1, ij.process.ImageProcessor image2, double binaryThreshold)` Get F-score of the variation of information in a concurrent way.
`ArrayList<Double>`	`getFscores(double minThreshold, double maxThreshold, double stepThreshold)` Get F-score of the variation of information over a set of thresholds
`double`	`getMaximalFScore(double minThreshold, double maxThreshold, double stepThreshold)` Get the best F-score of the variation of information over a set of thresholds
`double`	`getMaximalVInfoAfterThinning(double minThreshold, double maxThreshold, double stepThreshold)` Get the best V_Info after thinning over a set of thresholds.
`double`	`getMetricValue(double binaryThreshold)` Get variation of information between original and proposed labels for a given threshold
`double`	`getMinimumForegroundRestrictedMetricValue(double minThreshold, double maxThreshold, double stepThreshold)` Get the minimum foreground-restricted metric value over a set of thresholds
`double`	`getVI(ij.process.ShortProcessor cluster1, ij.process.ShortProcessor cluster2)` Calculate the variation of information between two clusters (N^2 normalization)
`Callable<Double>`	`getVIConcurrent(ij.process.ImageProcessor image1, ij.process.ImageProcessor image2, double binaryThreshold)` Calculate variation of information between two images in a concurrent way (to be submitted to an Executor Service).
`double`	`variationOfInformationN2(ij.process.ImageProcessor label, ij.process.ImageProcessor proposal, double binaryThreshold)` Calculate variation of information with N^2 normalization

Methods inherited from class trainableSegmentation.metrics.Metrics
getMinimumMetricValue, setVerboseMode

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

- Constructor Detail
  - VariationOfInformation
```
public VariationOfInformation(ij.ImagePlus originalLabels,
                              ij.ImagePlus proposedLabels)
```
    Initialize variation of information 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)
```
    Get variation of information between original and proposed labels for a given threshold
    
    Specified by:
    
    getMetricValue in class Metrics
    
    Parameters:
    
    binaryThreshold - threshold value to binarize labels
    
    Returns:
    
    metric value
  - getForegroundRestrictedMetricValue
```
public double getForegroundRestrictedMetricValue(double binaryThreshold)
```
    Get foreground-restricted variation of information between original and proposed labels for a given threshold
    
    Parameters:
    
    binaryThreshold - threshold value to binarize labels
    
    Returns:
    
    foreground-restricted metric value
  - getMinimumForegroundRestrictedMetricValue
```
public double getMinimumForegroundRestrictedMetricValue(double minThreshold,
                                                        double maxThreshold,
                                                        double stepThreshold)
```
    Get the minimum foreground-restricted metric value over a set of thresholds
    
    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:
    
    minimum foreground-restricted value of the metric
  - getVIConcurrent
```
public Callable<Double> getVIConcurrent(ij.process.ImageProcessor image1,
                                        ij.process.ImageProcessor image2,
                                        double binaryThreshold)
```
    Calculate variation of information between two images in a concurrent way (to be submitted to an Executor Service). Both images are binarized.
    
    Parameters:
    
    image1 - first image
    
    image2 - second image
    
    binaryThreshold - threshold to apply to both images
    
    Returns:
    
    variation of information
  - getForegroundRestrictedVIConcurrent
```
public Callable<Double> getForegroundRestrictedVIConcurrent(ij.process.ImageProcessor image1,
                                                            ij.process.ImageProcessor image2,
                                                            double binaryThreshold)
```
    Calculate foreground-restricted variation of information between two images in a concurrent way (to be submitted to an Executor Service). Both images are binarized.
    
    Parameters:
    
    image1 - first image
    
    image2 - second image
    
    binaryThreshold - threshold to apply to both images
    
    Returns:
    
    foreground-restricted variation of information
  - variationOfInformationN2
```
public double variationOfInformationN2(ij.process.ImageProcessor label,
                                       ij.process.ImageProcessor proposal,
                                       double binaryThreshold)
```
    Calculate variation of information with N^2 normalization
    
    Parameters:
    
    label - original labels
    
    proposal - proposed labels (usually a probability image to be thresholded)
    
    binaryThreshold - threshold value to binarize proposal
    
    Returns:
    
    variation of information between original labels and the binarized proposal
  - foregroundRestrictedVIN2
```
public double foregroundRestrictedVIN2(ij.process.ImageProcessor label,
                                       ij.process.ImageProcessor proposal,
                                       double binaryThreshold)
```
    Calculate foreground-restricted variation of information with N^2 normalization
    
    Parameters:
    
    label - original labels
    
    proposal - proposed labels (usually a probability image to be thresholded)
    
    binaryThreshold - threshold value to binarize proposal
    
    Returns:
    
    foreground-restricted variation of information between original labels and the binarized proposal
  - getVI
```
public double getVI(ij.process.ShortProcessor cluster1,
                    ij.process.ShortProcessor cluster2)
```
    Calculate the variation of information between two clusters (N^2 normalization)
    
    Parameters:
    
    cluster1 - labels of cluster 1 (ground truth)
    
    cluster2 - labels of cluster 2 (proposal)
    
    Returns:
    
    variation of information value
  - foregroundRestrictedVI
```
public double foregroundRestrictedVI(ij.process.ShortProcessor cluster1,
                                     ij.process.ShortProcessor cluster2)
```
    Calculate the variation of information between two clusters using the foreground restriction, i.e. pruning out the zero component in the labeling (un-assigned "out" space)
    
    Parameters:
    
    cluster1 - labels of cluster 1 (ground truth)
    
    cluster2 - labels of cluster 2 (proposal)
    
    Returns:
    
    foreground-restricted variation of information value
  - 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
  - getForegroundRestrictedMaximalFScore
```
public double getForegroundRestrictedMaximalFScore(double minThreshold,
                                                   double maxThreshold,
                                                   double stepThreshold)
```
    Get the best F-score of the foreground-restricted variation of information over a set of thresholds
    
    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 foreground-restricted variation of information
  - getMaximalVInfoAfterThinning
```
public double getMaximalVInfoAfterThinning(double minThreshold,
                                           double maxThreshold,
                                           double stepThreshold)
```
    Get the best V_Info 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.
    
    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 Information theoretic score after thinning
  - getMaximalFScore
```
public double getMaximalFScore(double minThreshold,
                               double maxThreshold,
                               double stepThreshold)
```
    Get the best F-score of the variation of information over a set of thresholds
    
    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 variation of information
  - getForegroundRestrictedFscores
```
public ArrayList<Double> getForegroundRestrictedFscores(double minThreshold,
                                                        double maxThreshold,
                                                        double stepThreshold)
```
    Get foreground-restricted F-score of the variation of information over a set of thresholds
    
    Parameters:
    
    minThreshold - minimum threshold value to check (included)
    
    maxThreshold - maximum threshold value to check (included)
    
    stepThreshold - step threshold value
    
    Returns:
    
    list with the F-score value of each threshold
  - getForegroundRestrictedScoresAfterThinning
```
public ArrayList<Double> getForegroundRestrictedScoresAfterThinning(double minThreshold,
                                                                    double maxThreshold,
                                                                    double stepThreshold)
```
    Get foreground-restricted information theoretic score after thinning over a set of thresholds
    
    Parameters:
    
    minThreshold - minimum threshold value to check (included)
    
    maxThreshold - maximum threshold value to check (included)
    
    stepThreshold - step threshold value
    
    Returns:
    
    list with the F-score value of each threshold
  - getFscores
```
public ArrayList<Double> getFscores(double minThreshold,
                                    double maxThreshold,
                                    double stepThreshold)
```
    Get F-score of the variation of information over a set of thresholds
    
    Parameters:
    
    minThreshold - minimum threshold value to check (included)
    
    maxThreshold - maximum threshold value to check (included)
    
    stepThreshold - step threshold value
    
    Returns:
    
    list with the F-score value of each threshold
  - getForegroundRestrictedFscore
```
public double getForegroundRestrictedFscore(double th)
```
    Get F-score of the foreground-restricted variation of information for a given threshold of the proposal labels. Done in 2d, for stacks, the average F-score is calculated.
    
    Parameters:
    
    th - threshold value to binarize proposal
    
    Returns:
    
    F-score of the foreground-restricted variation of information
  - getForegroundRestrictedScoreAfterThinning
```
public double getForegroundRestrictedScoreAfterThinning(double th)
```
    Get foreground-restricted information theoretic score after border thinning for a given threshold of the proposal labels. Done in 2d, for stacks, the per-slice average score is calculated.
    
    Parameters:
    
    th - threshold value to binarize proposal
    
    Returns:
    
    foreground-restricted information theoretic score after thinning
  - getForegroundRestrictedStatsPerSlice
```
public InformationStatistics[] getForegroundRestrictedStatsPerSlice(double binaryThreshold)
```
    Get the foreground-restricted variation of information statistics (entropy values, F-score, etc) per slice and for a given threshold value.
    
    Parameters:
    
    binaryThreshold - threshold value to binarize proposal ([0 1])
    
    Returns:
    
    foreground-restricted information statistics per slice
  - foregroundRestrictedStats
```
public InformationStatistics foregroundRestrictedStats(ij.process.ImageProcessor gt,
                                                       ij.process.ImageProcessor proposal,
                                                       double binaryThreshold)
```
    Get the foreground-restricted variation of information statistics (entropy values, F-score, etc)
    
    Parameters:
    
    gt - 2D image with the original labels
    
    proposal - 2D image with the proposed labels
    
    binaryThreshold - threshold value to binarize the input images
    
    Returns:
    
    variation of information statistics
  - getFscore
```
public double getFscore(double th)
```
    Get F-score of the variation of information for a given threshold of the proposal labels. Done in 2d, for stacks, the average F-score is calculated.
    
    Parameters:
    
    th - threshold value to binarize proposal
    
    Returns:
    
    F-score of the variation of information
  - getFscoreConcurrent
```
public Callable<Double> getFscoreConcurrent(ij.process.ImageProcessor image1,
                                            ij.process.ImageProcessor image2,
                                            double binaryThreshold)
```
    Get F-score of the variation of information in a concurrent way. To be submitted to an ExecutorService.
    
    Parameters:
    
    image1 - ground truth (usually binary labels)
    
    image2 - proposed labels (usually a probability map to binarize)
    
    binaryThreshold - threshold value to binarize proposal
    
    Returns:
    
    F-score of the variation of information (N^2 normalization)
  - getforegroundRestrictedFscoreConcurrent
```
public Callable<Double> getforegroundRestrictedFscoreConcurrent(ij.process.ImageProcessor image1,
                                                                ij.process.ImageProcessor image2,
                                                                double binaryThreshold)
```
    Get F-score of the foreground-restricted variation of information in a concurrent way. To be submitted to an ExecutorService.
    
    Parameters:
    
    image1 - ground truth (usually binary labels)
    
    image2 - proposed labels (usually a probability map to binarize)
    
    binaryThreshold - threshold value to binarize proposal
    
    Returns:
    
    F-score of the variation of information (foreground-restricted and N^2 normalization)
  - getforegroundRestrictedScoreAfterThinningConcurrent
```
public Callable<Double> getforegroundRestrictedScoreAfterThinningConcurrent(ij.process.ImageProcessor image1,
                                                                            ij.process.ImageProcessor image2,
                                                                            double binaryThreshold)
```
    Get foreground-restricted information theoretic score after border thinning in a concurrent way. To be submitted to an ExecutorService.
    
    Parameters:
    
    image1 - ground truth (usually binary labels)
    
    image2 - proposed labels (usually a probability map to binarize)
    
    binaryThreshold - threshold value to binarize proposal
    
    Returns:
    
    information theoretic score (foreground-restricted, proposal border thinning and N^2 normalization)
  - fScoreN2
```
public double fScoreN2(ij.process.ImageProcessor label,
                       ij.process.ImageProcessor proposal,
                       double binaryThreshold)
```
    Calculate F-score of variation of information with N^2 normalization
    
    Parameters:
    
    label - original labels
    
    proposal - proposed labels (usually a probability image to be thresholded)
    
    binaryThreshold - threshold value to binarize proposal
    
    Returns:
    
    F-score of the variation of information between original labels and the binarized proposal
  - foregroundRestrictedFScoreN2
```
public double foregroundRestrictedFScoreN2(ij.process.ImageProcessor label,
                                           ij.process.ImageProcessor proposal,
                                           double binaryThreshold)
```
    Calculate F-score of foreground-restricted variation of information with N^2 normalization
    
    Parameters:
    
    label - original labels
    
    proposal - proposed labels (usually a probability image to be thresholded)
    
    binaryThreshold - threshold value to binarize proposal
    
    Returns:
    
    F-score of the variation of information between original labels and the binarized proposal
  - foregroundRestrictedScoreAfterThinningN2
```
public double foregroundRestrictedScoreAfterThinningN2(ij.process.ImageProcessor label,
                                                       ij.process.ImageProcessor proposal,
                                                       double binaryThreshold)
```
    Calculate foreground-restricted information theoretic score with N^2 normalization after border thinning
    
    Parameters:
    
    label - original labels
    
    proposal - proposed labels (usually a probability image to be thresholded)
    
    binaryThreshold - threshold value to binarize proposal
    
    Returns:
    
    information theoretic score between original labels and the binarized proposal
  - foregroundRestrictedFscore
```
public double foregroundRestrictedFscore(ij.process.ShortProcessor cluster1,
                                         ij.process.ShortProcessor cluster2)
```
    Calculate the F-score of the variation of information between two clusters using the foreground restriction, i.e. pruning out the zero component in the labeling (un-assigned "out" space)
    
    Parameters:
    
    cluster1 - labels of cluster 1 (ground truth)
    
    cluster2 - labels of cluster 2 (proposal)
    
    Returns:
    
    F-score of the variation of information
  - foregroundRestrictedStats
```
public InformationStatistics foregroundRestrictedStats(ij.process.ShortProcessor cluster1,
                                                       ij.process.ShortProcessor cluster2)
```
    Calculate the variation of information statistics (entropy values, F-score, etc) between two clusters using the foreground restriction, i.e. pruning out the zero component in the labeling (un-assigned "out" space)
    
    Parameters:
    
    cluster1 - labels of cluster 1 (ground truth)
    
    cluster2 - labels of cluster 2 (proposal)
    
    Returns:
    
    variation of information statistics
  - fscore
```
public double fscore(ij.process.ShortProcessor cluster1,
                     ij.process.ShortProcessor cluster2)
```
    Calculate the F-score of the variation of information between two clusters A and B ( harmonic mean of C(A|B) and C(B|A) )
    
    Parameters:
    
    cluster1 - labels of cluster 1 (ground truth)
    
    cluster2 - labels of cluster 2 (proposal)
    
    Returns:
    
    F-score of the variation of information

Class VariationOfInformation

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

VariationOfInformation

Method Detail

getMetricValue

getForegroundRestrictedMetricValue

getMinimumForegroundRestrictedMetricValue

getVIConcurrent

getForegroundRestrictedVIConcurrent

variationOfInformationN2

foregroundRestrictedVIN2

getVI

foregroundRestrictedVI

getForegroundRestrictedGroundTruthDisagreements

getForegroundRestrictedPredictionDisagreements

getForegroundRestrictedMaximalFScore

getMaximalVInfoAfterThinning

getMaximalFScore

getForegroundRestrictedFscores

getForegroundRestrictedScoresAfterThinning

getFscores

getForegroundRestrictedFscore

getForegroundRestrictedScoreAfterThinning

getForegroundRestrictedStatsPerSlice

foregroundRestrictedStats

getFscore

getFscoreConcurrent

getforegroundRestrictedFscoreConcurrent

getforegroundRestrictedScoreAfterThinningConcurrent

fScoreN2

foregroundRestrictedFScoreN2

foregroundRestrictedScoreAfterThinningN2

foregroundRestrictedFscore

foregroundRestrictedStats

fscore