WarpingError (Fiji Javadocs 0-SNAPSHOT API)

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

public class WarpingError
extends Metrics

This class implements the warping error metric \cite{Jain10} BibTeX:

 @article{Jain10,
   author    = {V. Jain, B. Bollmann, M. Richardson, D.R. Berger, M.N. Helmstaedter, 
                                K.L. Briggman, W. Denk, J.B. Bowden, J.M. Mendenhall, W.C. Abraham, 
                                K.M. Harris, N. Kasthuri, K.J. Hayworth, R. Schalek, J.C. Tapia, 
                                J.W. Lichtman, S.H. Seung},
   title     = {Boundary Learning by Optimization with Topological Constraints},
   booktitle = {2010 IEEE CONFERENCE ON COMPUTER VISION AND PATTERN RECOGNITION (CVPR)},
   year      = {2010},
   series    = {IEEE Conference on Computer Vision and Pattern Recognition},
   pages     = {2488-2495},
   doi       = {10.1109/CVPR.2010.5539950)
 }

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DEFAULT_FLAGS` default flags
`static int`	`HOLE_ADDITION` hole addition error flag
`static int`	`HOLE_DELETION` hole deletion error flag
`static int`	`MERGE` merger flag
`static int`	`OBJECT_ADDITION` object addition error flag
`static int`	`OBJECT_DELETION` object deletion error flag
`static double`	`SIMPLE_POINT_THRESHOLD` simple point threshold value
`static int`	`SPLIT` split flag

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

Constructor Summary

Constructors
Constructor and Description
`WarpingError(ij.ImagePlus originalLabels, ij.ImagePlus proposedLabels)` Initialize warping error metric
`WarpingError(ij.ImagePlus originalLabels, ij.ImagePlus proposedLabels, ij.ImagePlus mask)` Initialize warping error metric
`WarpingError(ij.ImagePlus originalLabels, ij.ImagePlus proposedLabels, ij.ImagePlus mask, int flags)` Initialize warping error metric

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int[]`	`classifyMismatches2d(ij.ImagePlus warpedLabels, ArrayList<Point3f> mismatches, double falsePositives, double falseNegatives, int flags)` Classify warping mismatches as MERGE, SPLIT, HOLE_ADDITION, HOLE_DELETION, OBJECT_ADDITION, OBJECT_DELETION and count the number of false positives and false negatives
`int[]`	`classifyMismatches2d(ij.ImagePlus warpedLabels, ArrayList<Point3f> mismatches, int radius)` Classify warping mismatches as MERGE, SPLIT, HOLE_ADDITION, HOLE_DELETION, OBJECT_ADDITION, OBJECT_DELETION
`ClusteredWarpingMismatches`	`clusterMismatchesByError(ij.ImagePlus warpedLabels, ArrayList<Point3f> mismatches, int[] mismatchClassification)` Cluster the result mismatches from the warping so pixels belonging to the same error are only counted once.
`ClusteredWarpingMismatches`	`clusterMismatchesByType(int[] mismatchClassification)` Cluster the result mismatches from the warping by types of errors.
`ClusteredWarpingMismatches[]`	`getClusteredWarpingMismatches(ij.ImagePlus source, ij.ImagePlus target, ij.ImagePlus mask, double binaryThreshold, boolean clusterByError, int radius)` Get all the mismatches of warping a source image into a target image and clustering them when they belong to the same error.
`Callable<ClusteredWarpingMismatches>`	`getClusteredWarpingMismatchesConcurrent(ij.process.ImageProcessor source, ij.process.ImageProcessor target, ij.process.ImageProcessor mask, double binaryThreshold, boolean clusterByError, int radius)` Calculate the simple point warping in a concurrent way (to be submitted to an Executor Service)
`double`	`getDualPixelErrorMaximalFScore(double minThreshold, double maxThreshold, double stepThreshold)` Get the best F-score of the pixel error between proposed and original labels (and all the way around) over a set of thresholds
`ArrayList<ClassificationStatistics>`	`getDualPrecisionRecallStats(double minThreshold, double maxThreshold, double stepThreshold)` Calculate the precision-recall values based on pixel error between some warped 2D original labels and the corresponding proposed labels in both directions (from original labels to proposal and reversely).
`double`	`getMetricValue(double binaryThreshold)` Calculate the classic topology-preserving warping error \cite{Jain10} in 2D between some original labels and the corresponding proposed labels.
`double`	`getMetricValue(double binaryThreshold, boolean clusterByError)` Calculate the topology-preserving warping error in 2D between some original labels and the corresponding proposed labels.
`double`	`getMetricValue(double binaryThreshold, boolean clusterByError, int radius)` Calculate the topology-preserving warping error in 2D between some original labels and the corresponding proposed labels.
`double`	`getMinimumSplitsAndMergersErrorValue(double minThreshold, double maxThreshold, double stepThreshold, boolean clusterByError)` Calculate error with the minimum number of splits and mergers for different thresholds
`double`	`getMinimumSplitsAndMergersErrorValue(double minThreshold, double maxThreshold, double stepThreshold, boolean clusterByError, int radius)` Calculate error with the minimum number of splits and mergers for different thresholds
`ij.ImagePlus`	`getMismatchImage(WarpingResults wr, int radius)` Get the image with the classified mismatches
`ij.ImagePlus`	`getMismatchImage(WarpingResults wr, int[] mismatchesLabels, int flags)` Get the image with the classified mismatches
`ij.ImagePlus`	`getMismatchImage(WarpingResults wr, int radius, int flags)` Get the image with the classified mismatches
`ArrayList<Integer>`	`getNeighborhood(ij.process.ImageProcessor image, Point p, int x_offset, int y_offset)` Get neighborhood of a pixel in a 2D image
`double`	`getPixelErrorMaximalFScore(double minThreshold, double maxThreshold, double stepThreshold)` Get the best F-score of the pixel error between proposed and original labels over a set of thresholds
`ArrayList<ClassificationStatistics>`	`getPrecisionRecallStats(double minThreshold, double maxThreshold, double stepThreshold)` Calculate the precision-recall values based on pixel error between some warped 2D original labels and the corresponding proposed labels.
`ArrayList<ClassificationStatistics>`	`getPrecisionRecallStatsSplitsAndMergers(double minThreshold, double maxThreshold, double stepThreshold, int radius, boolean bordersArePositive, boolean visualize)` Calculate the precision-recall values based on pixel error between some warped 2D original labels and the corresponding proposed labels (taking into account only the split and merger pixels).
`ClassificationStatistics[]`	`getPrecisionRecallStatsSplitsAndMergersPerSlice(double th, int radius, boolean bordersArePositive)` Calculate the precision-recall values based on pixel error between some warped 2D original labels and the corresponding proposed labels (taking into account only the split and merger pixels).
`double`	`getRandIndexMaximalFScore(double minThreshold, double maxThreshold, double stepThreshold)` Get the best F-score of the Rand index based on Rand index between some warped 2D original labels and the corresponding proposed labels.
`ArrayList<ClassificationStatistics>`	`getRandIndexStats(double minThreshold, double maxThreshold, double stepThreshold)` Calculate the precision-recall values based on Rand index between some warped 2D original labels and the corresponding proposed labels.
`ArrayList<int[]>`	`getSplitsAndMergers(double minThreshold, double maxThreshold, double stepThreshold, boolean clusterByError)` Calculate the number of splits and mergers for different thresholds
`ArrayList<int[]>`	`getSplitsAndMergers(double minThreshold, double maxThreshold, double stepThreshold, boolean clusterByError, int radius)` Calculate the number of splits and mergers for different thresholds
`WarpingResults`	`getWarpingResults(double binaryThreshold, boolean clusterByError, boolean calculateMismatchImage, int radius)` Calculate warping error and return the related result images and values.
`Callable<WarpingResults>`	`getWarpingResultsConcurrent(ij.process.ImageProcessor source, ij.process.ImageProcessor target, ij.process.ImageProcessor mask, double binaryThreshold, boolean clusterByError, int radius, int flags, boolean calculateMismatchImage)` Calculate the simple point warping in a concurrent way (to be submitted to an Executor Service)
`static void`	`main(String[] args)` Main method for calcualte the warping error metrics from the command line
`boolean`	`simple2D(ij.ImagePlus im, int n)` Check if a point is simple (in 2D)
`boolean`	`simple2DBertrand(ij.ImagePlus im, int n)` Check if a point is simple (in 2D) based on 3D code from Mark Richardson inspired in the work of Bertrand et al.
`ij.ImagePlus`	`simplePointWarp2d(ij.ImagePlus source, ij.ImagePlus target, ij.ImagePlus mask, double binaryThreshold)` Use simple point relaxation to warp 2D source into 2D target.
`WarpingResults`	`simplePointWarp2d(ij.process.ImageProcessor source, ij.process.ImageProcessor target, ij.process.ImageProcessor mask, double binaryThreshold)` Use simple point relaxation to warp 2D source into 2D target.
`Callable<WarpingResults>`	`simplePointWarp2DConcurrent(ij.process.ImageProcessor source, ij.process.ImageProcessor target, ij.process.ImageProcessor mask, double binaryThreshold)` Calculate the simple point warping in a concurrent way (to be submitted to an Executor Service)
`Callable<WarpingResults>`	`simplePointWarp2DConcurrent(ij.process.ImageProcessor source, ij.process.ImageProcessor target, ij.process.ImageProcessor mask, double binaryThreshold, boolean calculateMismatchImage, int radius)` Calculate the simple point warping in a concurrent way (to be submitted to an Executor Service)
`WarpingResults[]`	`simplePointWarp2dMT(double binaryThreshold, boolean clusterByError, boolean calculateMismatchImage, int radius)` Use simple point relaxation to warp 2D labels into the 2D proposal.
`WarpingResults[]`	`simplePointWarp2dMT(ij.ImagePlus source, ij.ImagePlus target, ij.ImagePlus mask, double binaryThreshold)` Use simple point relaxation to warp 2D source into 2D target.
`ij.ImagePlus`	`simplePointWarp2dMT(ij.ImagePlus source, ij.ImagePlus target, ij.ImagePlus mask, double binaryThreshold, ArrayList<Point3f>[] mismatches)` Use simple point relaxation to warp 2D source into 2D target.
`int`	`topo(ij.ImagePlus im, int adjacency)` Computes topological numbers for the central point of an image patch.
`double`	`warpingErrorSingleThread(ij.ImagePlus label, ij.ImagePlus proposal, ij.ImagePlus mask, double binaryThreshold)` Calculate warping error (single thread version)

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

- Field Detail
  - SIMPLE_POINT_THRESHOLD
```
public static final double SIMPLE_POINT_THRESHOLD
```
    simple point threshold value
    
    See Also:
    
    Constant Field Values
  - MERGE
```
public static final int MERGE
```
    merger flag
    
    See Also:
    
    Constant Field Values
  - SPLIT
```
public static final int SPLIT
```
    split flag
    
    See Also:
    
    Constant Field Values
  - HOLE_ADDITION
```
public static final int HOLE_ADDITION
```
    hole addition error flag
    
    See Also:
    
    Constant Field Values
  - OBJECT_DELETION
```
public static final int OBJECT_DELETION
```
    object deletion error flag
    
    See Also:
    
    Constant Field Values
  - OBJECT_ADDITION
```
public static final int OBJECT_ADDITION
```
    object addition error flag
    
    See Also:
    
    Constant Field Values
  - HOLE_DELETION
```
public static final int HOLE_DELETION
```
    hole deletion error flag
    
    See Also:
    
    Constant Field Values
  - DEFAULT_FLAGS
```
public static final int DEFAULT_FLAGS
```
    default flags
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - WarpingError
```
public WarpingError(ij.ImagePlus originalLabels,
                    ij.ImagePlus proposedLabels)
```
    Initialize warping 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)
  - WarpingError
```
public WarpingError(ij.ImagePlus originalLabels,
                    ij.ImagePlus proposedLabels,
                    ij.ImagePlus mask)
```
    Initialize warping 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)
    
    mask - image mask containing in white the areas where warping is allowed (null for not geometric constraints)
  - WarpingError
```
public WarpingError(ij.ImagePlus originalLabels,
                    ij.ImagePlus proposedLabels,
                    ij.ImagePlus mask,
                    int flags)
```
    Initialize warping 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)
    
    mask - image mask containing in white the areas where warping is allowed (null for not geometric constraints)
    
    flags - flags to select which error should be taken into account and which not
- Method Detail
  - getMetricValue
```
public double getMetricValue(double binaryThreshold)
```
    Calculate the classic topology-preserving warping error \cite{Jain10} in 2D between some original labels and the corresponding proposed labels. Both, original and proposed labels are expected to have float values between 0 and 1. Otherwise, they will be converted. BibTeX:
```
 @article{Jain10,
   author    = {V. Jain, B. Bollmann, M. Richardson, D.R. Berger, M.N. Helmstaedter, 
                                K.L. Briggman, W. Denk, J.B. Bowden, J.M. Mendenhall, W.C. Abraham, 
                                K.M. Harris, N. Kasthuri, K.J. Hayworth, R. Schalek, J.C. Tapia, 
                                J.W. Lichtman, S.H. Seung},
   title     = {Boundary Learning by Optimization with Topological Constraints},
   booktitle = {2010 IEEE CONFERENCE ON COMPUTER VISION AND PATTERN RECOGNITION (CVPR)},
   year      = {2010},
   series    = {IEEE Conference on Computer Vision and Pattern Recognition},
   pages     = {2488-2495},
   doi       = {10.1109/CVPR.2010.5539950)
 }
 
```
    Specified by:
    
    getMetricValue in class Metrics
    
    Parameters:
    
    binaryThreshold - threshold value to binarize proposal (larger than 0 and smaller than 1)
    
    Returns:
    
    total warping error (it counts all type of mismatches as errors)
  - getMetricValue
```
public double getMetricValue(double binaryThreshold,
                             boolean clusterByError)
```
    Calculate the topology-preserving warping error in 2D between some original labels and the corresponding proposed labels. Pixels belonging to the same mistake will be only counted once. For example, if we have a line of 15 pixels that prevent from a merger, it will count as 1 instead of 15 as in the classic warping error method. Both, original and proposed labels are expected to have float values between 0 and 1. Otherwise, they will be converted.
    
    Parameters:
    
    binaryThreshold - threshold value to binarize proposal (larger than 0 and smaller than 1)
    
    clusterByError - if false, cluster mismatches by type, otherwise cluster them by error and type
    
    Returns:
    
    clustered warping error (it clusters the mismatches that belong to the same type and/or error together)
  - getMetricValue
```
public double getMetricValue(double binaryThreshold,
                             boolean clusterByError,
                             int radius)
```
    Calculate the topology-preserving warping error in 2D between some original labels and the corresponding proposed labels. Pixels belonging to the same mistake will be only counted once. For example, if we have a line of 15 pixels that prevent from a merger, it will count as 1 instead of 15 as in the classic warping error method. Both, original and proposed labels are expected to have float values between 0 and 1. Otherwise, they will be converted.
    
    Parameters:
    
    binaryThreshold - threshold value to binarize proposal (larger than 0 and smaller than 1)
    
    clusterByError - if false, cluster mismatches by type, otherwise cluster them by error and type
    
    radius - radius in pixels to use when classifying mismatches
    
    Returns:
    
    clustered warping error (it clusters the mismatches that belong to the same type and/or error together)
  - getSplitsAndMergers
```
public ArrayList<int[]> getSplitsAndMergers(double minThreshold,
                                            double maxThreshold,
                                            double stepThreshold,
                                            boolean clusterByError)
```
    Calculate the number of splits and mergers for different 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
    
    clusterByError - if false, cluster mismatches by type, otherwise cluster them by error and type
    
    Returns:
    
    list with arrays with the number of splits and mergers
  - getSplitsAndMergers
```
public ArrayList<int[]> getSplitsAndMergers(double minThreshold,
                                            double maxThreshold,
                                            double stepThreshold,
                                            boolean clusterByError,
                                            int radius)
```
    Calculate the number of splits and mergers for different 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
    
    clusterByError - if false, cluster mismatches by type, otherwise cluster them by error and type
    
    radius - radius in pixel to use when classifying mismatches
    
    Returns:
    
    list with arrays with the number of splits and mergers
  - getMinimumSplitsAndMergersErrorValue
```
public double getMinimumSplitsAndMergersErrorValue(double minThreshold,
                                                   double maxThreshold,
                                                   double stepThreshold,
                                                   boolean clusterByError)
```
    Calculate error with the minimum number of splits and mergers for different 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
    
    clusterByError - if false, cluster mismatches by type, otherwise cluster them by error and type
    
    Returns:
    
    list with arrays with the number of splits and mergers
  - getMinimumSplitsAndMergersErrorValue
```
public double getMinimumSplitsAndMergersErrorValue(double minThreshold,
                                                   double maxThreshold,
                                                   double stepThreshold,
                                                   boolean clusterByError,
                                                   int radius)
```
    Calculate error with the minimum number of splits and mergers for different 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
    
    clusterByError - if false, cluster mismatches by type, otherwise cluster them by error and type
    
    radius - radius in pixel to use when classifying mismatches
    
    Returns:
    
    list with arrays with the number of splits and mergers
  - getPixelErrorMaximalFScore
```
public double getPixelErrorMaximalFScore(double minThreshold,
                                         double maxThreshold,
                                         double stepThreshold)
```
    Get the best F-score of the pixel error between proposed and original labels 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 pixel error
  - getPrecisionRecallStats
```
public ArrayList<ClassificationStatistics> getPrecisionRecallStats(double minThreshold,
                                                                   double maxThreshold,
                                                                   double stepThreshold)
```
    Calculate the precision-recall values based on pixel error between some warped 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:
    
    pixel error value and derived statistics for each threshold
  - getPrecisionRecallStatsSplitsAndMergers
```
public ArrayList<ClassificationStatistics> getPrecisionRecallStatsSplitsAndMergers(double minThreshold,
                                                                                   double maxThreshold,
                                                                                   double stepThreshold,
                                                                                   int radius,
                                                                                   boolean bordersArePositive,
                                                                                   boolean visualize)
```
    Calculate the precision-recall values based on pixel error between some warped 2D original labels and the corresponding proposed labels (taking into account only the split and merger pixels).
    
    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
    
    radius - radius in pixels of the local area to look when deciding how to classify some mismatch cases (small radius speed up the method a lot, -1 to use whole image
    
    bordersArePositive - set to true if border pixels are positive samples
    
    visualize - set to true to display images
    
    Returns:
    
    pixel error value and derived statistics for each threshold
  - getPrecisionRecallStatsSplitsAndMergersPerSlice
```
public ClassificationStatistics[] getPrecisionRecallStatsSplitsAndMergersPerSlice(double th,
                                                                                  int radius,
                                                                                  boolean bordersArePositive)
```
    Calculate the precision-recall values based on pixel error between some warped 2D original labels and the corresponding proposed labels (taking into account only the split and merger pixels). Results are presented per slice.
    
    Parameters:
    
    th - threshold value to binarize the input images
    
    radius - radius in pixels of the local area to look when deciding how to classify some mismatch cases (small radius speed up the method a lot, -1 to use whole image
    
    bordersArePositive - set to true if border pixels are positive samples
    
    Returns:
    
    pixel error value and derived statistics for each slice
  - getDualPixelErrorMaximalFScore
```
public double getDualPixelErrorMaximalFScore(double minThreshold,
                                             double maxThreshold,
                                             double stepThreshold)
```
    Get the best F-score of the pixel error between proposed and original labels (and all the way around) 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 pixel error
  - getDualPrecisionRecallStats
```
public ArrayList<ClassificationStatistics> getDualPrecisionRecallStats(double minThreshold,
                                                                       double maxThreshold,
                                                                       double stepThreshold)
```
    Calculate the precision-recall values based on pixel error between some warped 2D original labels and the corresponding proposed labels in both directions (from original labels to proposal and reversely).
    
    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:
    
    pixel error value and derived statistics for each threshold
  - getRandIndexStats
```
public ArrayList<ClassificationStatistics> getRandIndexStats(double minThreshold,
                                                             double maxThreshold,
                                                             double stepThreshold)
```
    Calculate the precision-recall values based on Rand index between some warped 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:
    
    Rand index value and derived statistics for each threshold
  - getRandIndexMaximalFScore
```
public double getRandIndexMaximalFScore(double minThreshold,
                                        double maxThreshold,
                                        double stepThreshold)
```
    Get the best F-score of the Rand index based on Rand index between some warped 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:
    
    maximal F-score of the Rand index
  - simple2DBertrand
```
public boolean simple2DBertrand(ij.ImagePlus im,
                                int n)
```
    Check if a point is simple (in 2D) based on 3D code from Mark Richardson inspired in the work of Bertrand et al. \cite{Bertrand94} BibTeX:
```
 @article{Bertrand94,
   author    = {Bertrand, Gilles and Malandain, Gr\'{e}goire},
   title     = {A new characterization of three-dimensional simple points},
   journal   = {Pattern Recogn. Lett.},
   volume    = {15},
   issue     = {2},
   month     = {February},
   year      = {1994},
   issn      = {0167-8655},
   pages     = {169--175},
   numpages  = {7},
   url       = {http://dl.acm.org/citation.cfm?id=179348.179356},
   doi       = {10.1016/0167-8655(94)90046-9},
   acmid     = {179356},
   publisher = {Elsevier Science Inc.},
   address   = {New York, NY, USA},
   keywords  = {digital topology, simple points, thinning algorithms, three dimensions},
 }
 
```
    Parameters:
    
    im - input patch
    
    n - neighbors
    
    Returns:
    
    true if the center pixel of the patch is a simple point
  - simple2D
```
public boolean simple2D(ij.ImagePlus im,
                        int n)
```
    Check if a point is simple (in 2D)
    
    Parameters:
    
    im - input patch
    
    n - neighbors
    
    Returns:
    
    true if the center pixel of the patch is a simple point
  - topo
```
public int topo(ij.ImagePlus im,
                int adjacency)
```
    Computes topological numbers for the central point of an image patch. These numbers can be used as the basis of a topological classification. T_4 and T_8 are used when IM is a 2d image patch of size 3x3 defined on p. 172 of Bertrand & Malandain, Patt. Recog. Lett. 15, 169-75 (1994).
    
    Parameters:
    
    im - input image
    
    adjacency - number of neighbors
    
    Returns:
    
    number of components in the patch excluding the center pixel
  - simplePointWarp2d
```
public WarpingResults simplePointWarp2d(ij.process.ImageProcessor source,
                                        ij.process.ImageProcessor target,
                                        ij.process.ImageProcessor mask,
                                        double binaryThreshold)
```
    Use simple point relaxation to warp 2D source into 2D target. Source is only modified at nonzero locations in the mask
    
    Parameters:
    
    source - input 2D image to be relaxed
    
    target - target 2D image
    
    mask - 2D image mask
    
    binaryThreshold - binarization threshold
    
    Returns:
    
    warped source image and warping error
  - simplePointWarp2DConcurrent
```
public Callable<WarpingResults> simplePointWarp2DConcurrent(ij.process.ImageProcessor source,
                                                            ij.process.ImageProcessor target,
                                                            ij.process.ImageProcessor mask,
                                                            double binaryThreshold)
```
    Calculate the simple point warping in a concurrent way (to be submitted to an Executor Service)
    
    Parameters:
    
    source - moving image
    
    target - fixed image
    
    mask - mask image
    
    binaryThreshold - binary threshold to use
    
    Returns:
    
    warping results (warped labels, warping error value and mismatching points)
  - simplePointWarp2DConcurrent
```
public Callable<WarpingResults> simplePointWarp2DConcurrent(ij.process.ImageProcessor source,
                                                            ij.process.ImageProcessor target,
                                                            ij.process.ImageProcessor mask,
                                                            double binaryThreshold,
                                                            boolean calculateMismatchImage,
                                                            int radius)
```
    Calculate the simple point warping in a concurrent way (to be submitted to an Executor Service)
    
    Parameters:
    
    source - moving image
    
    target - fixed image
    
    mask - mask image
    
    binaryThreshold - binary threshold to use
    
    radius - radius in pixels to use while classifying pixels
    
    Returns:
    
    warping results (warped labels, warping error value and mismatching points)
  - getMismatchImage
```
public ij.ImagePlus getMismatchImage(WarpingResults wr,
                                     int radius)
```
    Get the image with the classified mismatches
    
    Parameters:
    
    wr - warping results
    
    radius - radius in pixels to use while classifying pixels
    
    Returns:
    
    image with classified mismatches
  - getMismatchImage
```
public ij.ImagePlus getMismatchImage(WarpingResults wr,
                                     int radius,
                                     int flags)
```
    Get the image with the classified mismatches
    
    Parameters:
    
    wr - warping results
    
    radius - radius in pixels to use while classifying pixels
    
    Returns:
    
    image with classified mismatches
  - getMismatchImage
```
public ij.ImagePlus getMismatchImage(WarpingResults wr,
                                     int[] mismatchesLabels,
                                     int flags)
```
    Get the image with the classified mismatches
    
    Parameters:
    
    wr - warping results
    
    mismatchesLabels - labels of the warping mismatches
    
    Returns:
    
    image with classified mismatches
  - simplePointWarp2dMT
```
public ij.ImagePlus simplePointWarp2dMT(ij.ImagePlus source,
                                        ij.ImagePlus target,
                                        ij.ImagePlus mask,
                                        double binaryThreshold,
                                        ArrayList<Point3f>[] mismatches)
```
    Use simple point relaxation to warp 2D source into 2D target. Source is only modified at nonzero locations in the mask (multi-thread version)
    
    Parameters:
    
    source - input image to be relaxed
    
    target - target image
    
    mask - image mask
    
    binaryThreshold - binarization threshold
    
    mismatches - list of points that could not be flipped
    
    Returns:
    
    warped source image
  - simplePointWarp2d
```
public ij.ImagePlus simplePointWarp2d(ij.ImagePlus source,
                                      ij.ImagePlus target,
                                      ij.ImagePlus mask,
                                      double binaryThreshold)
```
    Use simple point relaxation to warp 2D source into 2D target. Source is only modified at nonzero locations in the mask
    
    Parameters:
    
    source - input image to be relaxed
    
    target - target image
    
    mask - image mask
    
    binaryThreshold - binarization threshold
    
    Returns:
    
    warped source image
  - simplePointWarp2dMT
```
public WarpingResults[] simplePointWarp2dMT(ij.ImagePlus source,
                                            ij.ImagePlus target,
                                            ij.ImagePlus mask,
                                            double binaryThreshold)
```
    Use simple point relaxation to warp 2D source into 2D target. Source is only modified at nonzero locations in the mask (multi-thread version)
    
    Parameters:
    
    source - input image to be relaxed (2D image or stack)
    
    target - target image (2D image or stack)
    
    mask - image mask (2D image or stack)
    
    binaryThreshold - binarization threshold
    
    Returns:
    
    warping results for each slice of the source
  - simplePointWarp2dMT
```
public WarpingResults[] simplePointWarp2dMT(double binaryThreshold,
                                            boolean clusterByError,
                                            boolean calculateMismatchImage,
                                            int radius)
```
    Use simple point relaxation to warp 2D labels into the 2D proposal. Source is only modified at nonzero locations in the mask (multi-thread version)
    
    Parameters:
    
    binaryThreshold - binarization threshold
    
    clusterByError - if false, cluster mismatches by type, otherwise cluster them by error and type
    
    calculateMismatchImage - boolean flag to calculate mismatch image
    
    radius - radius in pixels to use while classifying mismatches
    
    Returns:
    
    warping results for each slice of the source
  - warpingErrorSingleThread
```
public double warpingErrorSingleThread(ij.ImagePlus label,
                                       ij.ImagePlus proposal,
                                       ij.ImagePlus mask,
                                       double binaryThreshold)
```
    Calculate warping error (single thread version)
    
    Parameters:
    
    label - original labels (single image or stack)
    
    proposal - proposed new labels
    
    mask - image mask
    
    binaryThreshold - binary threshold to binarize proposal
    
    Returns:
    
    total warping error
  - getClusteredWarpingMismatches
```
public ClusteredWarpingMismatches[] getClusteredWarpingMismatches(ij.ImagePlus source,
                                                                  ij.ImagePlus target,
                                                                  ij.ImagePlus mask,
                                                                  double binaryThreshold,
                                                                  boolean clusterByError,
                                                                  int radius)
```
    Get all the mismatches of warping a source image into a target image and clustering them when they belong to the same error. Simple point relaxation is used for the warping. The source is only modified at nonzero locations in the mask (multi-thread static version)
    
    Parameters:
    
    source - input image to be relaxed (2D image or stack)
    
    target - target image (2D image or stack)
    
    mask - image mask (2D image or stack)
    
    binaryThreshold - binarization threshold
    
    clusterByError - if false, cluster mismatches by type, otherwise cluster them by error and type
    
    radius - radius in pixels of the local area to look when deciding some cases (small radius speed up the method a lot, -1 to use whole image)
    
    Returns:
    
    clustered warping mismatches for each slice of the source
  - getClusteredWarpingMismatchesConcurrent
```
public Callable<ClusteredWarpingMismatches> getClusteredWarpingMismatchesConcurrent(ij.process.ImageProcessor source,
                                                                                    ij.process.ImageProcessor target,
                                                                                    ij.process.ImageProcessor mask,
                                                                                    double binaryThreshold,
                                                                                    boolean clusterByError,
                                                                                    int radius)
```
    Calculate the simple point warping in a concurrent way (to be submitted to an Executor Service)
    
    Parameters:
    
    source - moving image
    
    target - fixed image
    
    mask - mask image
    
    binaryThreshold - binary threshold to use
    
    clusterByError - boolean flag to use clustering by error or only by type
    
    radius - radius in pixels of the local area to look when deciding some cases (small radius speed up the method a lot, -1 to use whole image)
    
    Returns:
    
    clustered mismatching points after warping
  - getWarpingResultsConcurrent
```
public Callable<WarpingResults> getWarpingResultsConcurrent(ij.process.ImageProcessor source,
                                                            ij.process.ImageProcessor target,
                                                            ij.process.ImageProcessor mask,
                                                            double binaryThreshold,
                                                            boolean clusterByError,
                                                            int radius,
                                                            int flags,
                                                            boolean calculateMismatchImage)
```
    Calculate the simple point warping in a concurrent way (to be submitted to an Executor Service)
    
    Parameters:
    
    source - moving image
    
    target - fixed image
    
    mask - mask image
    
    binaryThreshold - binary threshold to use
    
    clusterByError - boolean flag to use clustering by error or only by type
    
    radius - radius in pixels of the local area to look when deciding some cases (small radius speed up the method a lot, -1 to use whole image)
    
    flags - flags indicating the type of errors to take into account
    
    calculateMismatchImage - boolean flag to determine if the mismatches image should be calculated
    
    Returns:
    
    clustered mismatching points after warping
  - classifyMismatches2d
```
public int[] classifyMismatches2d(ij.ImagePlus warpedLabels,
                                  ArrayList<Point3f> mismatches,
                                  int radius)
```
    Classify warping mismatches as MERGE, SPLIT, HOLE_ADDITION, HOLE_DELETION, OBJECT_ADDITION, OBJECT_DELETION
    
    Parameters:
    
    warpedLabels - labels after warping (binary image)
    
    mismatches - list of mismatch points after warping
    
    radius - radius in pixels of the local area to look when deciding some cases (small radius speed up the method a lot, -1 to use whole image)
    
    Returns:
    
    array of mismatch classifications
  - classifyMismatches2d
```
public int[] classifyMismatches2d(ij.ImagePlus warpedLabels,
                                  ArrayList<Point3f> mismatches,
                                  double falsePositives,
                                  double falseNegatives,
                                  int flags)
```
    Classify warping mismatches as MERGE, SPLIT, HOLE_ADDITION, HOLE_DELETION, OBJECT_ADDITION, OBJECT_DELETION and count the number of false positives and false negatives
    
    Parameters:
    
    warpedLabels - labels after warping (binary image)
    
    mismatches - list of mismatch points after warping
    
    falsePositives - (output) number of false positives
    
    falseNegatives - (output) number of false negatives
    
    flags -
    
    Returns:
    
    array of mismatch classifications
  - clusterMismatchesByError
```
public ClusteredWarpingMismatches clusterMismatchesByError(ij.ImagePlus warpedLabels,
                                                           ArrayList<Point3f> mismatches,
                                                           int[] mismatchClassification)
```
    Cluster the result mismatches from the warping so pixels belonging to the same error are only counted once.
    
    Parameters:
    
    warpedLabels - result warped labels
    
    mismatches - list of non simple points
    
    mismatchClassification - array of classified mismatches
    
    Returns:
    
    number of warping mismatches after clustering by error
  - clusterMismatchesByType
```
public ClusteredWarpingMismatches clusterMismatchesByType(int[] mismatchClassification)
```
    Cluster the result mismatches from the warping by types of errors.
    
    Parameters:
    
    mismatchClassification - array of classified mismatches
    
    Returns:
    
    number of warping mismatches after clustering by type
  - getNeighborhood
```
public ArrayList<Integer> getNeighborhood(ij.process.ImageProcessor image,
                                          Point p,
                                          int x_offset,
                                          int y_offset)
```
    Get neighborhood of a pixel in a 2D image
    
    Parameters:
    
    image - 2D image
    
    p - point coordinates
    
    x_offset - x- neighborhood offset
    
    y_offset - y- neighborhood offset
    
    Returns:
    
    corresponding neighborhood
  - main
```
public static void main(String[] args)
```
    Main method for calcualte the warping error metrics from the command line
    
    Parameters:
    
    args - arguments to decide the action
  - getWarpingResults
```
public WarpingResults getWarpingResults(double binaryThreshold,
                                        boolean clusterByError,
                                        boolean calculateMismatchImage,
                                        int radius)
```
    Calculate warping error and return the related result images and values.
    
    Parameters:
    
    binaryThreshold - threshold value to binarize proposal (larger than 0 and smaller than 1)
    
    clusterByError - if false, cluster topology errors by type, otherwise cluster by type and mistake
    
    calculateMismatchImage - flag to calculate mismatch image
    
    radius - radius in pixels to use when classifiying mismatches
    
    Returns:
    
    total warping error (it counts all type of mismatches as errors)

Class WarpingError

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

Field Detail

SIMPLE_POINT_THRESHOLD

MERGE

SPLIT

HOLE_ADDITION

OBJECT_DELETION

OBJECT_ADDITION

HOLE_DELETION

DEFAULT_FLAGS

Constructor Detail

WarpingError

WarpingError

WarpingError

Method Detail

getMetricValue

getMetricValue

getMetricValue

getSplitsAndMergers

getSplitsAndMergers

getMinimumSplitsAndMergersErrorValue

getMinimumSplitsAndMergersErrorValue

getPixelErrorMaximalFScore

getPrecisionRecallStats

getPrecisionRecallStatsSplitsAndMergers

getPrecisionRecallStatsSplitsAndMergersPerSlice

getDualPixelErrorMaximalFScore

getDualPrecisionRecallStats

getRandIndexStats

getRandIndexMaximalFScore

simple2DBertrand

simple2D

topo

simplePointWarp2d

simplePointWarp2DConcurrent

simplePointWarp2DConcurrent

getMismatchImage

getMismatchImage

getMismatchImage

simplePointWarp2dMT

simplePointWarp2d

simplePointWarp2dMT

simplePointWarp2dMT

warpingErrorSingleThread

getClusteredWarpingMismatches

getClusteredWarpingMismatchesConcurrent

getWarpingResultsConcurrent

classifyMismatches2d

classifyMismatches2d

clusterMismatchesByError

clusterMismatchesByType

getNeighborhood

main

getWarpingResults