ComputeCurvatures (Fiji Javadocs 0-SNAPSHOT API)

java.lang.Object
- features.ComputeCurvatures

All Implemented Interfaces:

Runnable
```
public class ComputeCurvatures
extends Object
implements Runnable
```
Principle Curvature Plugin for ImageJ
Description: Computes the Principle Curvatures of for 2D and 3D images except the pixels/voxels directly at the borders of the image

Changes in this version:
- Made the top level plugin a wrapper for this class so that "features" package so that it can be used by classes in other packages.
- Now implements Runnable, with the void run() method creating the Gaussian and reporting progress via an optional callback. (If used in this way you need to use the constructor where you supply an ImagePlus, sigma and an optional callback.
- Switched to using Johannes's JacobiDouble / JacobiFloat classes for finding the eigenvalues instead of the Jama classes, so we don't introduce an additional dependency. It's about 15% faster with JacobiDouble, but I haven't yet measured any speed gain due to using floats rather than doubles.
- Added options to only generate particular eigenvalue images, and some other slight changes to the initial dialog.
- Added additional methods using floats for calculation (and the interface) in case clients only need floats.
- Added ordering of the eigenvalues (optionally on absolute values).
- Added normalisation of the eigenvalues to that the largest has size 1 (some papers use methods that require this)
- Now we take notice of the calibration information (or not, if that option is deselected).
- Use some faster eigenvalue calculation code for the 3x3 case.
Version:

1.0

Author:

Stephan Preibisch, Mark Longair

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`ComputeCurvatures.FloatArray` This class is the abstract class for my FloatArrayXDs, which are a one dimensional structures with methods for access in n dimensions
`class`	`ComputeCurvatures.FloatArray2D` The 2D implementation of the FloatArray
`class`	`ComputeCurvatures.FloatArray3D` The 3D implementation of the FloatArray

Field Summary

Fields
Modifier and Type Field and Description

protected GaussianGenerationCallback callback

protected ij.ImagePlus imp

protected double sigma

protected boolean useCalibration

Fields
Modifier and Type	Field and Description
`protected GaussianGenerationCallback`	`callback`
`protected ij.ImagePlus`	`imp`
`protected double`	`sigma`
`protected boolean`	`useCalibration`

Constructor Summary

Constructors
Constructor and Description
`ComputeCurvatures()`
`ComputeCurvatures(ij.ImagePlus imp, double sigma, GaussianGenerationCallback callback, boolean useCalibration)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`cancelGaussianGeneration()`
`double[]`	`computeEigenValues(double[][] matrix)` This method computes the Eigenvalues of the Hessian Matrix, the Eigenvalues correspond to the Principle Curvatures.
`float[]`	`computeEigenValues(float[][] matrix)` This method computes the Eigenvalues of the Hessian Matrix, the Eigenvalues correspond to the Principle Curvatures.
`ComputeCurvatures.FloatArray2D`	`computeGaussianFastMirror(ComputeCurvatures.FloatArray2D input, float sigma, GaussianGenerationCallback callback, ij.measure.Calibration calibration)` This method does the gaussian filtering of an image.
`ComputeCurvatures.FloatArray3D`	`computeGaussianFastMirror(ComputeCurvatures.FloatArray3D input, float sigma, GaussianGenerationCallback callback, ij.measure.Calibration calibration)` This method does the gaussian filtering of an 3D image.
`double[][]`	`computeHessianMatrix2DDouble(ComputeCurvatures.FloatArray2D laPlace, int x, int y, double sigma, float sepX, float sepY)` This method computes the Hessian Matrix for the 3x3 environment of a certain pixel The 3D Hessian Matrix: xx xy yx yy
`float[][]`	`computeHessianMatrix2DFloat(ComputeCurvatures.FloatArray2D laPlace, int x, int y, double sigma, float sepX, float sepY)` This method computes the Hessian Matrix for the 3x3 environment of a certain pixel The 3D Hessian Matrix: xx xy yx yy
`double[][]`	`computeHessianMatrix3DDouble(ComputeCurvatures.FloatArray3D img, int x, int y, int z, double sigma, float sepX, float sepY, float sepZ)` This method computes the Hessian Matrix for the 3x3x3 environment of a certain voxel The 3D Hessian Matrix: xx xy xz yx yy yz zx zy zz
`float[][]`	`computeHessianMatrix3DFloat(ComputeCurvatures.FloatArray3D img, int x, int y, int z, double sigma, float sepX, float sepY, float sepZ)` This method computes the Hessian Matrix for the 3x3x3 environment of a certain voxel The 3D Hessian Matrix: xx xy xz yx yy yz zx zy zz
`static float[]`	`createGaussianKernel1D(float sigma, boolean normalize)` This method creates a gaussian kernel
`static void`	`FloatArrayToFloatProcessor(ij.process.ImageProcessor ip, ComputeCurvatures.FloatArray2D pixels)` This method converts my FloatArray2D to an ImageJ ImageProcessor
`static ij.ImagePlus`	`FloatArrayToImagePlus(ComputeCurvatures.FloatArray2D image, String name, float min, float max)` This method converts my FloatArray2D to an ImageJ ImagePlus
`ij.ImagePlus`	`FloatArrayToStack(ComputeCurvatures.FloatArray3D image, String name, float min, float max)` This method converts my FloatArray3D to an ImageJ image stack packed into an ImagePlus
`boolean`	`hessianEigenvaluesAtPoint2D(int x, int y, boolean orderOnAbsoluteSize, double[] result, boolean normalize, boolean fixUp, float sepX, float sepY)`
`boolean`	`hessianEigenvaluesAtPoint2D(int x, int y, boolean orderOnAbsoluteSize, float[] result, boolean normalize, boolean fixUp, float sepX, float sepY)`
`boolean`	`hessianEigenvaluesAtPoint3D(int x, int y, int z, boolean orderOnAbsoluteSize, double[] result, boolean normalize, boolean fixUp, float sepX, float sepY, float sepZ)`
`boolean`	`hessianEigenvaluesAtPoint3D(int x, int y, int z, boolean orderOnAbsoluteSize, float[] result, boolean normalize, boolean fixUp, float sepX, float sepY, float sepZ)`
`ComputeCurvatures.FloatArray2D`	`ImageToFloatArray(ij.process.ImageProcessor ip)` This method convertes an ImageJ ImageProcessor to my FloatArray2D, which is a one dimensional structure with methods for 2D access
`void`	`run()`
`void`	`runAsPlugIn(String arg)` This method will be called when running the PlugIn, it coordinates the main process.
`void`	`setup()`
`ComputeCurvatures.FloatArray3D`	`StackToFloatArray(ij.ImageStack stack)` This method convertes an ImageJ image stack to my FloatArray3D, which is a one dimensional structure with methods for 3D access

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

Field Detail

imp
```
protected ij.ImagePlus imp
```

sigma
```
protected double sigma
```

useCalibration
```
protected boolean useCalibration
```

callback

protected GaussianGenerationCallback callback

Constructor Detail

ComputeCurvatures
```
public ComputeCurvatures()
```

ComputeCurvatures

public ComputeCurvatures(ij.ImagePlus imp,
                         double sigma,
                         GaussianGenerationCallback callback,
                         boolean useCalibration)

Method Detail

runAsPlugIn
```
public void runAsPlugIn(String arg)
```
This method will be called when running the PlugIn, it coordinates the main process.

Parameters:

arg - UNUSED

cancelGaussianGeneration

public void cancelGaussianGeneration()

run
```
public void run()
```
Specified by:

run in interface Runnable

setup
```
public void setup()
```

hessianEigenvaluesAtPoint2D

public boolean hessianEigenvaluesAtPoint2D(int x,
                                           int y,
                                           boolean orderOnAbsoluteSize,
                                           float[] result,
                                           boolean normalize,
                                           boolean fixUp,
                                           float sepX,
                                           float sepY)

hessianEigenvaluesAtPoint2D

public boolean hessianEigenvaluesAtPoint2D(int x,
                                           int y,
                                           boolean orderOnAbsoluteSize,
                                           double[] result,
                                           boolean normalize,
                                           boolean fixUp,
                                           float sepX,
                                           float sepY)

hessianEigenvaluesAtPoint3D

public boolean hessianEigenvaluesAtPoint3D(int x,
                                           int y,
                                           int z,
                                           boolean orderOnAbsoluteSize,
                                           float[] result,
                                           boolean normalize,
                                           boolean fixUp,
                                           float sepX,
                                           float sepY,
                                           float sepZ)

hessianEigenvaluesAtPoint3D

public boolean hessianEigenvaluesAtPoint3D(int x,
                                           int y,
                                           int z,
                                           boolean orderOnAbsoluteSize,
                                           double[] result,
                                           boolean normalize,
                                           boolean fixUp,
                                           float sepX,
                                           float sepY,
                                           float sepZ)

FloatArrayToImagePlus
```
public static ij.ImagePlus FloatArrayToImagePlus(ComputeCurvatures.FloatArray2D image,
                                                 String name,
                                                 float min,
                                                 float max)
```
This method converts my FloatArray2D to an ImageJ ImagePlus

Parameters:

image - The image as FloatArray2D

name - The name of the ImagePlus

min - Lowest brightness value that will be displayed (see Brightness&Contrast in Imagej)

max - Highest brightness value that will be displayed (set both to zero for automatic)

Returns:

ImagePlus The ImageJ image

FloatArrayToFloatProcessor

public static void FloatArrayToFloatProcessor(ij.process.ImageProcessor ip,
                                              ComputeCurvatures.FloatArray2D pixels)

This method converts my FloatArray2D to an ImageJ ImageProcessor

Parameters:: ip - ImageProcessor; will be overwritten with the data from the FloatArray2D; pixels - The image as FloatArray2D

FloatArrayToStack
```
public ij.ImagePlus FloatArrayToStack(ComputeCurvatures.FloatArray3D image,
                                      String name,
                                      float min,
                                      float max)
```
This method converts my FloatArray3D to an ImageJ image stack packed into an ImagePlus

Parameters:

image - The image as FloatArray3D

name - The name of the ImagePlus

min - Lowest brightness value that will be displayed (see Brightness&Contrast in Imagej)

max - Highest brightness value that will be displayed (set both to zero for automatic)

Returns:

ImagePlus The ImageJ image

computeEigenValues
```
public double[] computeEigenValues(double[][] matrix)
```
This method computes the Eigenvalues of the Hessian Matrix, the Eigenvalues correspond to the Principle Curvatures. (MHL modified to use the JacobiDouble class in math3d, or an optimized version for the special case of 3x3 matrices.)

Note: If the Eigenvalues contain imaginary numbers, this method will return null

Parameters:

matrix - The hessian Matrix

Returns:

The Real Parts of the Eigenvalues or null (if there were imganiary parts)

computeEigenValues
```
public float[] computeEigenValues(float[][] matrix)
```
This method computes the Eigenvalues of the Hessian Matrix, the Eigenvalues correspond to the Principle Curvatures. (MHL modified to use the JacobiFloat class in math3d.)

Note: If the Eigenvalues contain imaginary numbers, this method will return null

Parameters:

matrix - float[][] The hessian Matrix

Returns:

The Real Parts of the Eigenvalues or null (if there were imganiary parts)

computeHessianMatrix2DDouble

public double[][] computeHessianMatrix2DDouble(ComputeCurvatures.FloatArray2D laPlace,
                                               int x,
                                               int y,
                                               double sigma,
                                               float sepX,
                                               float sepY)

This method computes the Hessian Matrix for the 3x3 environment of a certain pixel

The 3D Hessian Matrix:
xx xy
yx yy

Parameters:: laPlace - The image as FloatArray3D; x - The x-position of the voxel; y - The y-position of the voxel
Returns:: double[][] The 2D - Hessian Matrix

computeHessianMatrix2DFloat

public float[][] computeHessianMatrix2DFloat(ComputeCurvatures.FloatArray2D laPlace,
                                             int x,
                                             int y,
                                             double sigma,
                                             float sepX,
                                             float sepY)

This method computes the Hessian Matrix for the 3x3 environment of a certain pixel

The 3D Hessian Matrix:
xx xy
yx yy

Parameters:: laPlace - The image as FloatArray3D; x - The x-position of the voxel; y - The y-position of the voxel; sigma -; sepX -; sepY -
Returns:: The 2D - Hessian Matrix

computeHessianMatrix3DDouble

public double[][] computeHessianMatrix3DDouble(ComputeCurvatures.FloatArray3D img,
                                               int x,
                                               int y,
                                               int z,
                                               double sigma,
                                               float sepX,
                                               float sepY,
                                               float sepZ)

This method computes the Hessian Matrix for the 3x3x3 environment of a certain voxel

The 3D Hessian Matrix:
xx xy xz
yx yy yz
zx zy zz

Parameters:: img - The image as FloatArray3D; x - The x-position of the voxel; y - The y-position of the voxel; z - The z-position of the voxel
Returns:: double[][] The 3D - Hessian Matrix

computeHessianMatrix3DFloat

public float[][] computeHessianMatrix3DFloat(ComputeCurvatures.FloatArray3D img,
                                             int x,
                                             int y,
                                             int z,
                                             double sigma,
                                             float sepX,
                                             float sepY,
                                             float sepZ)

This method computes the Hessian Matrix for the 3x3x3 environment of a certain voxel

The 3D Hessian Matrix:
xx xy xz
yx yy yz
zx zy zz

Parameters:: img - The image as FloatArray3D; x - The x-position of the voxel; y - The y-position of the voxel; z - The z-position of the voxel
Returns:: float[][] The 3D - Hessian Matrix

createGaussianKernel1D
```
public static float[] createGaussianKernel1D(float sigma,
                                             boolean normalize)
```
This method creates a gaussian kernel

Parameters:

sigma - Standard Derivation of the gaussian function

normalize - Normalize integral of gaussian function to 1 or not...

Returns:

float[] The gaussian kernel

computeGaussianFastMirror

public ComputeCurvatures.FloatArray2D computeGaussianFastMirror(ComputeCurvatures.FloatArray2D input,
                                                                float sigma,
                                                                GaussianGenerationCallback callback,
                                                                ij.measure.Calibration calibration)

This method does the gaussian filtering of an image. On the edges of the image it does mirror the pixels. It also uses the seperability of the gaussian convolution.

Parameters:: input - FloatProcessor which will be folded (will not be touched); sigma - Standard Derivation of the gaussian function
Returns:: FloatProcessor The folded image

computeGaussianFastMirror
```
public ComputeCurvatures.FloatArray3D computeGaussianFastMirror(ComputeCurvatures.FloatArray3D input,
                                                                float sigma,
                                                                GaussianGenerationCallback callback,
                                                                ij.measure.Calibration calibration)
```
This method does the gaussian filtering of an 3D image. On the edges of the image it does mirror the pixels. It also uses the seperability of the gaussian convolution.

Parameters:

input - FloatProcessor which will be folded (will not be touched)

sigma - Standard Derivation of the gaussian function

calibration - Calibration data for the image, or null if we assume separation in all three dimensions is 1

Returns:

FloatProcessor The folded image

StackToFloatArray
```
public ComputeCurvatures.FloatArray3D StackToFloatArray(ij.ImageStack stack)
```
This method convertes an ImageJ image stack to my FloatArray3D, which is a one dimensional structure with methods for 3D access

Parameters:

stack - ImageJ image stack

Returns:

FloatArray3D The image packed into a FloatArray3D

ImageToFloatArray
```
public ComputeCurvatures.FloatArray2D ImageToFloatArray(ij.process.ImageProcessor ip)
```
This method convertes an ImageJ ImageProcessor to my FloatArray2D, which is a one dimensional structure with methods for 2D access

Parameters:

ip - ImageJ ImageProcessor

Returns:

FloatArray2D The image packed into a FloatArray2D

Class ComputeCurvatures

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

imp

sigma

useCalibration

callback

Constructor Detail

ComputeCurvatures

ComputeCurvatures

Method Detail

runAsPlugIn

cancelGaussianGeneration

run

setup

hessianEigenvaluesAtPoint2D

hessianEigenvaluesAtPoint2D

hessianEigenvaluesAtPoint3D

hessianEigenvaluesAtPoint3D

FloatArrayToImagePlus

FloatArrayToFloatProcessor

FloatArrayToStack

computeEigenValues

computeEigenValues

computeHessianMatrix2DDouble

computeHessianMatrix2DFloat

computeHessianMatrix3DDouble

computeHessianMatrix3DFloat

createGaussianKernel1D

computeGaussianFastMirror

computeGaussianFastMirror

StackToFloatArray

ImageToFloatArray