trainableSegmentation.metrics

Class WarpingError

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

Modifier and Type	Method and Description
int[]	classifyMismatches2d(ij.ImagePlus warpedLabels, ArrayList<org.jogamp.vecmath.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<org.jogamp.vecmath.Point3f> mismatches, int radius) Classify warping mismatches as MERGE, SPLIT, HOLE_ADDITION, HOLE_DELETION, OBJECT_ADDITION, OBJECT_DELETION
ClusteredWarpingMismatches	clusterMismatchesByError(ij.ImagePlus warpedLabels, ArrayList<org.jogamp.vecmath.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<org.jogamp.vecmath.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<org.jogamp.vecmath.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<org.jogamp.vecmath.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<org.jogamp.vecmath.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<org.jogamp.vecmath.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)