gov.nih.mipav.model.algorithms.AlgorithmConvolver

All Implemented Interfaces:: ActionListener, WindowListener, Runnable, EventListener

public class AlgorithmConvolver extends AlgorithmBase

Convolves kernel with a 2D or 3D image - only pixels where the kernel is completely contained in the image are convolved, otherwise they are set to zero. This is reasonable since data at the edges of images is rarely used and large kernels should not be used since it is much faster to perform FFT, filter, and IFFT. The break even point is probably around a kernel size of 11 or so.

Since this class extends the AlgorithmBase class that extends the Thread class it can be run in its own thread by invoking algoConvolver3DObj.start(); It can also be invoked without a new thread by calling the the run() method directly (ie. algoConvolver3DObj.run()).

Source image is exported (locked and unlocked by export)
Kernel is exported
Image is convolved with kernel
Return

Version:: 0.1 Aug 1, 1997
Author:: Matthew J. McAuliffe, Ph.D.

Nested Class Summary

Nested classes/interfaces inherited from class java.lang.Thread
Thread.Builder, Thread.State, Thread.UncaughtExceptionHandler
Field Summary

Fields

Modifier and Type

Field

Description

private boolean

bilateral

private boolean

blue

private boolean

combined2D3D

private boolean

doXY

private boolean

entireImage

private boolean

green

private double

intensityGaussianDenom

private float[]

kernelBuffer

private float[]

kernelBufferX

private float[]

kernelBufferX2

private float[]

kernelBufferXX

private float[]

kernelBufferXXX

private float[]

kernelBufferXXY

private float[]

kernelBufferXXZ

private float[]

kernelBufferXY

private float[]

kernelBufferXYY

private float[]

kernelBufferXYZ

private float[]

kernelBufferXZ

private float[]

kernelBufferXZZ

private float[]

kernelBufferY

private float[]

kernelBufferY2

private float[]

kernelBufferYY

private float[]

kernelBufferYYY

private float[]

kernelBufferYYZ

private float[]

kernelBufferYZ

private float[]

kernelBufferYZZ

private float[]

kernelBufferZ

private float[]

kernelBufferZZ

private float[]

kernelBufferZZZ

private int[]

kExtents

The image data to convolve.

private boolean

nms2

private boolean

nms2e

private boolean

nms3

private boolean

nms3e

private float[]

outputBuffer

private boolean

red

private boolean

sqrtXY

private boolean

sqrtXYZ

Fields inherited from class gov.nih.mipav.model.algorithms.AlgorithmBase
destFlag, destImage, image25D, mask, maxProgressValue, minProgressValue, multiThreadingEnabled, nthreads, progress, progressModulus, progressStep, runningInSeparateThread, separable, srcImage, threadStopped

Fields inherited from class java.lang.Thread
MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY
Constructor Summary

Constructors

Constructor

Description

AlgorithmConvolver(ModelImage srcImage, float[] kernelX, float[] kernelY, float[] kernelZ, float[] kernelXX, float[] kernelXY, float[] kernelYY, float[] kernelXZ, float[] kernelYZ, float[] kernelZZ, boolean entireImage, int[] kExtents)

AlgorithmConvolver(ModelImage srcImage, float[] kernelX, float[] kernelY, float[] kernelZ, float[] kernelXX, float[] kernelXY, float[] kernelYY, float[] kernelXZ, float[] kernelYZ, float[] kernelZZ, float[] kernelXXX, float[] kernelXXY, float[] kernelXYY, float[] kernelYYY, float[] kernelXXZ, float[] kernelXZZ, float[] kernelXYZ, float[] kernelYYZ, float[] kernelYZZ, float[] kernelZZZ, int[] kExtents, boolean entireImage)

AlgorithmConvolver(ModelImage srcImage, float[] kernelX, float[] kernelY, float[] kernelXX, float[] kernelXY, float[] kernelYY, float[] kernelXXX, float[] kernelXXY, float[] kernelXYY, float[] kernelYYY, int[] kExtents, boolean entireImage)

AlgorithmConvolver(ModelImage srcImage, float[] kernelX, float[] kernelY, float[] kernelXX, float[] kernelXY, float[] kernelYY, int[] kExtents, boolean entireImage)

AlgorithmConvolver(ModelImage srcImage, float[] kernelX, float[] kernelY, float[] kernelZ, float[] kernelX2, float[] kernelY2, int[] kExtents, boolean entireImage, boolean combined2D3D)

AlgorithmConvolver(ModelImage srcImage, float[] kernelX, float[] kernelY, float[] kernelZ, int[] kExtents, boolean entireImage)

AlgorithmConvolver(ModelImage srcImage, float[] kernelX, float[] kernelY, int[] kExtents, boolean entireImage, boolean sqrtXY)

AlgorithmConvolver(ModelImage srcImage, float[] kernel, int[] kExtents, boolean entireImage, boolean image25D)

Sets the source and kernel images and calls the appropriate method based on image dimensionality.

AlgorithmConvolver(ModelImage srcImage, float[] kernel, int[] kExtents, boolean entireImage, boolean image25D, double intensityGaussianDenom)
Method Summary

Modifier and Type

Method

Description

private final void

convolve2D(int startSlice, int endSlice)

private final void

convolve2D3D(int start, int end, float[] iImage, int index, int min3DLength, int max3DLength)

private final void

convolve2DBilateral(int startSlice, int endSlice)

private final void

convolve2DNMS(int startSlice, int endSlice)

private final void

convolve2DNMSE(int startSlice, int endSlice)

static final float

convolve2DPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)

A static function that convolves a kernel with an image at a position.

static final double

convolve2DPt(WildMagic.LibFoundation.Mathematics.Vector2d pt, int[] iExtents, double[] image, int[] kExtents, double[] kernel)

A static function that convolves a kernel with an image at a position.

static final float

convolve2DPt(WildMagic.LibFoundation.Mathematics.Vector2f pt, int[] iExtents, float[] image, int[] kExtents, float[] kernel)

A static function that convolves a kernel with an image at a position.

static final float

convolve2DPtMed(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)

A static function that convolves a kernel with an image at a position.

static final float

convolve2DPtNMS(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY, float[] kernelXX, float[] kernelXY, float[] kernelYY)

A static function that convolves a kernel with an image at a position.

static final float

convolve2DPtNMSE(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY, float[] kernelXXX, float[] kernelXXY, float[] kernelXYY, float[] kernelYYY)

A static function that convolves a kernel with an image at a position.

static final float

convolve2DPtSqrtXY(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY)

A static function that convolves a kernel with an image at a position.

static final float

convolve2DRGBPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)

A static function that convolves a kernel with an RGB image at a position.

static final float

convolve2DRGBPtSqrtXY(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY)

A static function that convolves a kernel with an RGB image at a position.

private final void

convolve2DSqrtXY(int startSlice, int endSlice)

private final void

convolve2DXY(int startSlice, int endSlice)

private final void

convolve3D(int start, int end, float[] iImage, int index)

private final void

convolve3DBilateral(int start, int end, float[] iImage, int index)

private final void

convolve3DNMS(int start, int end, float[] iImage, int index)

private final void

convolve3DNMSE(int start, int end, float[] iImage, int index)

static final float

convolve3DPt(float[] pt, int[] iExtents, float[] image, int[] kExtents, float[] kernel)

A static function that convolves a kernel with an image at a position.

static final float

convolve3DPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)

A static function that convolves a kernel with an image at a position.

static final float

convolve3DPt(WildMagic.LibFoundation.Mathematics.Vector3f kPt, ModelImage kImage, int[] kExtents, float[] kernel)

A static function that convolves a kernel with an image at a position.

static final float

convolve3DPtMed(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)

A static function that convolves a kernel with an image at a position.

static final float

convolve3DPtNMS(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY, float[] kernelZ, float[] kernelXX, float[] kernelXY, float[] kernelYY, float[] kernelXZ, float[] kernelYZ, float[] kernelZZ)

A static function that convolves a kernel with an image at a position.

static final float

convolve3DPtNMSE(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY, float[] kernelZ, float[] kernelXXX, float[] kernelXXY, float[] kernelXYY, float[] kernelYYY, float[] kernelXXZ, float[] kernelXZZ, float[] kernelXYZ, float[] kernelYYZ, float[] kernelYZZ, float[] kernelZZZ)

A static function that convolves a kernel with an image at a position.

static final float

convolve3DPtXYZ(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY, float[] kernelZ)

A static function that convolves a kernel with an image at a position.

static final float

convolve3DRGBPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)

A static function that convolves a kernel with an RGB image at a position.

static final float

convolve3DRGBPtXYZ(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY, float[] kernelZ)

A static function that convolves a kernel with an RGB image at a position.

private final void

convolve3DXYZ(int start, int end, float[] iImage, int index)

static final float[]

convolveBilateral2DCIELabPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel, double intensityGaussianDenom)

A static function that convolves a kernel with an CIELab image at a position.

static final float

convolveBilateral2DPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel, double intensityGaussianDenom)

A static function that convolves a kernel with an image at a position.

static final float[]

convolveBilateral3DCIELabPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel, double intensityGaussianDenom)

A static function that convolves a kernel with a CIELab image at a position.

static final float

convolveBilateral3DPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel, double intensityGaussianDenom)

A static function that convolves a kernel with an image at a position.

static final void

convolveBlock3D(int start, int end, int lpv, float[] iImage, int[] iExtents, int[] kExtents, float[] kernel, ModelImage oImage)

static final float

convolveWhole2DPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)

A static function that convolves a kernel with an image at a position.

static final float

convolveWhole3DPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)

A static function that convolves a kernel with an image at a position The convolution is performed only if the whole kernel fits inside the image.

void

finalize()

Prepares this class for destruction.

private static double

getBilinear(int i, double dx, double dy, int[] iExtents, double[] image)

Performs bilinear interpolation of image data.

private static float

getBilinear(int i, float dx, float dy, int[] iExtents, float[] image)

Performs bilinear interpolation of image data.

float[]

getOutputBuffer()

Returns the output buffer

private static float

getTrilinear(int i1, float dx, float dy, float dz, int[] iExtents, float[] image)

Performs trilinear interpolation of image data.

static byte[]

getTrilinearC(int i1, float dx, float dy, float dz, int[] iExtents, byte[] image)

Performs trilinear interpolation of image data.

boolean

isBlue()

boolean

isGreen()

boolean

isRed()

void

run2D()

Begins the execution of the 2D convolver.

void

run3D()

Begins the execution of the 3D convolver.

void

run4D()

void

runAlgorithm()

Begins execution of the convolver.

void

setBlue(boolean blue)

void

setColorChannels(boolean red, boolean green, boolean blue)

void

setGreen(boolean green)

void

setRed(boolean red)

Methods inherited from class gov.nih.mipav.model.algorithms.AlgorithmBase
actionPerformed, addListener, addProgressChangeListener, calculateImageSize, calculatePrincipleAxis, computeElapsedTime, computeElapsedTime, convertIntoFloat, delinkProgressToAlgorithm, delinkProgressToAlgorithmMulti, displayError, errorCleanUp, fireProgressStateChanged, fireProgressStateChanged, fireProgressStateChanged, fireProgressStateChanged, fireProgressStateChanged, generateProgressValues, getDestImage, getElapsedTime, getMask, getMaxProgressValue, getMinProgressValue, getNumberOfThreads, getProgress, getProgressChangeListener, getProgressChangeListeners, getProgressModulus, getProgressStep, getProgressValues, getSrcImage, isCompleted, isImage25D, isMultiThreadingEnabled, isRunningInSeparateThread, isThreadStopped, linkProgressToAlgorithm, linkProgressToAlgorithm, makeProgress, notifyListeners, removeListener, removeProgressChangeListener, run, setCompleted, setImage25D, setMask, setMaxProgressValue, setMinProgressValue, setMultiThreadingEnabled, setNumberOfThreads, setProgress, setProgressModulus, setProgressStep, setProgressValues, setProgressValues, setRunningInSeparateThread, setSrcImage, setStartTime, setThreadStopped, startMethod, windowActivated, windowClosed, windowClosing, windowDeactivated, windowDeiconified, windowIconified, windowOpened

Methods inherited from class java.lang.Thread
activeCount, checkAccess, clone, countStackFrames, currentThread, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, isVirtual, join, join, join, join, ofPlatform, ofVirtual, onSpinWait, resume, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, sleep, start, startVirtualThread, stop, suspend, threadId, toString, yield

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

Field Details
- kExtents
  
  private int[] kExtents
  
  The image data to convolve.
- kernelBuffer
  
  private float[] kernelBuffer
- kernelBufferX
  
  private float[] kernelBufferX
- kernelBufferY
  
  private float[] kernelBufferY
- kernelBufferZ
  
  private float[] kernelBufferZ
- kernelBufferX2
  
  private float[] kernelBufferX2
- kernelBufferY2
  
  private float[] kernelBufferY2
- kernelBufferXX
  
  private float[] kernelBufferXX
- kernelBufferXY
  
  private float[] kernelBufferXY
- kernelBufferYY
  
  private float[] kernelBufferYY
- kernelBufferXZ
  
  private float[] kernelBufferXZ
- kernelBufferYZ
  
  private float[] kernelBufferYZ
- kernelBufferZZ
  
  private float[] kernelBufferZZ
- kernelBufferXXX
  
  private float[] kernelBufferXXX
- kernelBufferXXY
  
  private float[] kernelBufferXXY
- kernelBufferXYY
  
  private float[] kernelBufferXYY
- kernelBufferYYY
  
  private float[] kernelBufferYYY
- kernelBufferXXZ
  
  private float[] kernelBufferXXZ
- kernelBufferXZZ
  
  private float[] kernelBufferXZZ
- kernelBufferXYZ
  
  private float[] kernelBufferXYZ
- kernelBufferYYZ
  
  private float[] kernelBufferYYZ
- kernelBufferYZZ
  
  private float[] kernelBufferYZZ
- kernelBufferZZZ
  
  private float[] kernelBufferZZZ
- red
  
  private boolean red
- blue
  
  private boolean blue
- green
  
  private boolean green
- outputBuffer
  
  private float[] outputBuffer
- entireImage
  
  private boolean entireImage
- doXY
  
  private boolean doXY
- sqrtXY
  
  private boolean sqrtXY
- sqrtXYZ
  
  private boolean sqrtXYZ
- nms2
  
  private boolean nms2
- nms2e
  
  private boolean nms2e
- nms3
  
  private boolean nms3
- nms3e
  
  private boolean nms3e
- combined2D3D
  
  private boolean combined2D3D
- intensityGaussianDenom
  
  private double intensityGaussianDenom
- bilateral
  
  private boolean bilateral
Constructor Details
- AlgorithmConvolver
  
  public AlgorithmConvolver(ModelImage srcImage, float[] kernel, int[] kExtents, boolean entireImage, boolean image25D)
  
  Sets the source and kernel images and calls the appropriate method based on image dimensionality.
  
  Parameters:
  
  srcImage -
  
  kernel -
  
  kExtents -
  
  entireImage -
  
  image25D -
- AlgorithmConvolver
  
  public AlgorithmConvolver(ModelImage srcImage, float[] kernel, int[] kExtents, boolean entireImage, boolean image25D, double intensityGaussianDenom)
- AlgorithmConvolver
  
  public AlgorithmConvolver(ModelImage srcImage, float[] kernelX, float[] kernelY, int[] kExtents, boolean entireImage, boolean sqrtXY)
- AlgorithmConvolver
  
  public AlgorithmConvolver(ModelImage srcImage, float[] kernelX, float[] kernelY, float[] kernelZ, int[] kExtents, boolean entireImage)
- AlgorithmConvolver
  
  public AlgorithmConvolver(ModelImage srcImage, float[] kernelX, float[] kernelY, float[] kernelXX, float[] kernelXY, float[] kernelYY, int[] kExtents, boolean entireImage)
- AlgorithmConvolver
  
  public AlgorithmConvolver(ModelImage srcImage, float[] kernelX, float[] kernelY, float[] kernelXX, float[] kernelXY, float[] kernelYY, float[] kernelXXX, float[] kernelXXY, float[] kernelXYY, float[] kernelYYY, int[] kExtents, boolean entireImage)
- AlgorithmConvolver
  
  public AlgorithmConvolver(ModelImage srcImage, float[] kernelX, float[] kernelY, float[] kernelZ, float[] kernelXX, float[] kernelXY, float[] kernelYY, float[] kernelXZ, float[] kernelYZ, float[] kernelZZ, boolean entireImage, int[] kExtents)
- AlgorithmConvolver
  
  public AlgorithmConvolver(ModelImage srcImage, float[] kernelX, float[] kernelY, float[] kernelZ, float[] kernelXX, float[] kernelXY, float[] kernelYY, float[] kernelXZ, float[] kernelYZ, float[] kernelZZ, float[] kernelXXX, float[] kernelXXY, float[] kernelXYY, float[] kernelYYY, float[] kernelXXZ, float[] kernelXZZ, float[] kernelXYZ, float[] kernelYYZ, float[] kernelYZZ, float[] kernelZZZ, int[] kExtents, boolean entireImage)
- AlgorithmConvolver
  
  public AlgorithmConvolver(ModelImage srcImage, float[] kernelX, float[] kernelY, float[] kernelZ, float[] kernelX2, float[] kernelY2, int[] kExtents, boolean entireImage, boolean combined2D3D)
Method Details
- isRed
  
  public boolean isRed()
- setRed
  
  public void setRed(boolean red)
- isBlue
  
  public boolean isBlue()
- setBlue
  
  public void setBlue(boolean blue)
- isGreen
  
  public boolean isGreen()
- setGreen
  
  public void setGreen(boolean green)
- setColorChannels
  
  public void setColorChannels(boolean red, boolean green, boolean blue)
- convolve2DPt
  
  public static final float convolve2DPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)
  
  A static function that convolves a kernel with an image at a position.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolveBilateral2DPt
  
  public static final float convolveBilateral2DPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel, double intensityGaussianDenom)
  
  A static function that convolves a kernel with an image at a position. The intensity difference between the center pixel and the indexed pixel is used in a Gaussian in the weighing. The intensity Gaussian is (1.0/(Math.sqrt(2.0 * Math.PI) * intensitySigma))* exp(-intensityDifference**2/intenDenom) Since the same (1.0/(Math.sqrt(2.0 * Math.PI) * intensitySigma) term would appear in every weight term, it would cancel out by appearing in both the numerator and denominator in (sum / norm) and so can be omitted.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  intensityGaussianDenom -
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolve2DPtSqrtXY
  
  public static final float convolve2DPtSqrtXY(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY)
  
  A static function that convolves a kernel with an image at a position.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernelX - kernel data
  
  kernelY - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolve2DPtNMS
  
  public static final float convolve2DPtNMS(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY, float[] kernelXX, float[] kernelXY, float[] kernelYY)
  
  A static function that convolves a kernel with an image at a position.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernelX - kernel data
  
  kernelY - kernel data
  
  kernelXX - kernel data
  
  kernelXY - kernel data
  
  kernelYY - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolve2DPtNMSE
  
  public static final float convolve2DPtNMSE(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY, float[] kernelXXX, float[] kernelXXY, float[] kernelXYY, float[] kernelYYY)
  
  A static function that convolves a kernel with an image at a position.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernelX - kernel data
  
  kernelY - kernel data
  
  kernelXXX - kernel data
  
  kernelXXY - kernel data
  
  kernelXYY - kernel data
  
  kernelYYY - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolve2DPt
  
  public static final float convolve2DPt(WildMagic.LibFoundation.Mathematics.Vector2f pt, int[] iExtents, float[] image, int[] kExtents, float[] kernel)
  
  A static function that convolves a kernel with an image at a position.
  
  Parameters:
  
  pt - floating point indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolve2DPt
  
  public static final double convolve2DPt(WildMagic.LibFoundation.Mathematics.Vector2d pt, int[] iExtents, double[] image, int[] kExtents, double[] kernel)
  
  A static function that convolves a kernel with an image at a position.
  
  Parameters:
  
  pt - floating point indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolve2DPtMed
  
  public static final float convolve2DPtMed(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)
  
  A static function that convolves a kernel with an image at a position. This version seems to just be used by AlgorithmLapMedianess.
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
  
  See Also:
  
  AlgorithmLapMedianess
- convolve2DRGBPt
  
  public static final float convolve2DRGBPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)
  
  A static function that convolves a kernel with an RGB image at a position.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolveBilateral2DCIELabPt
  
  public static final float[] convolveBilateral2DCIELabPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel, double intensityGaussianDenom)
  
  A static function that convolves a kernel with an CIELab image at a position. The CIE76 intensity difference between the center pixel and the indexed pixel is used in a Gaussian in the weighing. The intensity Gaussian is (1.0/(Math.sqrt(2.0 * Math.PI) * intensitySigma))* exp(-intensityDifference**2/intenDenom) Since the same (1.0/(Math.sqrt(2.0 * Math.PI) * intensitySigma) term would appear in every weight term, it would cancel out by appearing in both the numerator and denominator in (sum / norm) and so can be omitted.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  intensityGaussianDenom -
  
  Returns:
  
  the L*,a*,b* of the pixel after convolution with the kernel
- convolve2DRGBPtSqrtXY
  
  public static final float convolve2DRGBPtSqrtXY(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY)
  
  A static function that convolves a kernel with an RGB image at a position.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernelX - kernel data
  
  kernelY - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolve3DPt
  
  public static final float convolve3DPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)
  
  A static function that convolves a kernel with an image at a position.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolveBilateral3DPt
  
  public static final float convolveBilateral3DPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel, double intensityGaussianDenom)
  
  A static function that convolves a kernel with an image at a position. The intensity difference between the center pixel and the indexed pixel is used in a Gaussian in the weighing. The intensity Gaussian is (1.0/(Math.sqrt(2.0 * Math.PI) * intensitySigma))* exp(-intensityDifference**2/intenDenom) Since the same (1.0/(Math.sqrt(2.0 * Math.PI) * intensitySigma) term would appear in every weight term, it would cancel out by appearing in both the numerator and denominator in (sum / norm) and so can be omitted.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  intensityGaussianDenom -
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolve3DPtXYZ
  
  public static final float convolve3DPtXYZ(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY, float[] kernelZ)
  
  A static function that convolves a kernel with an image at a position.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernelX - kernel data
  
  kernelY - kernel data
  
  kernelZ - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolve3DPtNMS
  
  public static final float convolve3DPtNMS(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY, float[] kernelZ, float[] kernelXX, float[] kernelXY, float[] kernelYY, float[] kernelXZ, float[] kernelYZ, float[] kernelZZ)
  
  A static function that convolves a kernel with an image at a position.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernelX - kernel data
  
  kernelY - kernel data
  
  kernelZ - kernel data
  
  kernelXX - kernel data
  
  kernelXY - kernel data
  
  kernelYY - kernel data
  
  kernelXZ - kernel data
  
  kernelYZ - kernel data
  
  kernelZZ - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolve3DPtNMSE
  
  public static final float convolve3DPtNMSE(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY, float[] kernelZ, float[] kernelXXX, float[] kernelXXY, float[] kernelXYY, float[] kernelYYY, float[] kernelXXZ, float[] kernelXZZ, float[] kernelXYZ, float[] kernelYYZ, float[] kernelYZZ, float[] kernelZZZ)
  
  A static function that convolves a kernel with an image at a position.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernelX - kernel data
  
  kernelY - kernel data
  
  kernelZ - kernel data
  
  kernelXXX - kernel data
  
  kernelXXY - kernel data
  
  kernelXYY - kernel data
  
  kernelYYY - kernel data
  
  kernelXXZ - kernel data
  
  kernelXZZ - kernel data
  
  kernelXYZ - kernel data
  
  kernelYZZ - kernel data
  
  kernelZZZ - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolveBlock3D
  
  public static final void convolveBlock3D(int start, int end, int lpv, float[] iImage, int[] iExtents, int[] kExtents, float[] kernel, ModelImage oImage)
  
  Parameters:
  
  start -
  
  end -
  
  iImage -
  
  iExtents -
  
  kExtents -
  
  kernel -
  
  oImage -
  
  lpp - length per voxel, for example 4 for RGB image.
- convolve3DPt
  
  public static final float convolve3DPt(float[] pt, int[] iExtents, float[] image, int[] kExtents, float[] kernel)
  
  A static function that convolves a kernel with an image at a position.
  
  Parameters:
  
  pt - floating point indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolve3DPtMed
  
  public static final float convolve3DPtMed(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)
  
  A static function that convolves a kernel with an image at a position. This version seems to just be used by AlgorithmLapMedianess.
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
  
  See Also:
  
  AlgorithmLapMedianess
- convolve3DRGBPt
  
  public static final float convolve3DRGBPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)
  
  A static function that convolves a kernel with an RGB image at a position.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolveBilateral3DCIELabPt
  
  public static final float[] convolveBilateral3DCIELabPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel, double intensityGaussianDenom)
  
  A static function that convolves a kernel with a CIELab image at a position. The CIE76 intensity difference between the center pixel and the indexed pixel is used in a Gaussian in the weighing. The intensity Gaussian is (1.0/(Math.sqrt(2.0 * Math.PI) * intensitySigma))* exp(-intensityDifference**2/intenDenom) Since the same (1.0/(Math.sqrt(2.0 * Math.PI) * intensitySigma) term would appear in every weight term, it would cancel out by appearing in both the numerator and denominator in (sum / norm) and so can be omitted.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  intensityGaussianDenom -
  
  Returns:
  
  the L*,a*,b* of the pixel after convolution with the kernel
- convolve3DRGBPtXYZ
  
  public static final float convolve3DRGBPtXYZ(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernelX, float[] kernelY, float[] kernelZ)
  
  A static function that convolves a kernel with an RGB image at a position.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernelX - kernel data
  
  kernelY - kernel data
  
  kernelZ - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolveWhole2DPt
  
  public static final float convolveWhole2DPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)
  
  A static function that convolves a kernel with an image at a position. The convolution is performed only if the whole kernel fits inside the image.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel or 0 if the kernel does not fit wholly within the image
- convolveWhole3DPt
  
  public static final float convolveWhole3DPt(int pix, int[] iExtents, float[] image, int[] kExtents, float[] kernel)
  
  A static function that convolves a kernel with an image at a position The convolution is performed only if the whole kernel fits inside the image.
  
  Parameters:
  
  pix - index indicating location of convolution
  
  iExtents - image dimensions
  
  image - image data
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel or 0 if the kernel does not fit wholly within the image
- convolve3DPt
  
  public static final float convolve3DPt(WildMagic.LibFoundation.Mathematics.Vector3f kPt, ModelImage kImage, int[] kExtents, float[] kernel)
  
  A static function that convolves a kernel with an image at a position.
  
  Parameters:
  
  kExtents - kernel dimensions
  
  kernel - kernel data
  
  Returns:
  
  the value of the pixel after convolution with the kernel
- convolve2D
  
  private final void convolve2D(int startSlice, int endSlice)
- convolve2DBilateral
  
  private final void convolve2DBilateral(int startSlice, int endSlice)
- convolve2DXY
  
  private final void convolve2DXY(int startSlice, int endSlice)
- convolve2DSqrtXY
  
  private final void convolve2DSqrtXY(int startSlice, int endSlice)
- convolve2DNMS
  
  private final void convolve2DNMS(int startSlice, int endSlice)
- convolve2DNMSE
  
  private final void convolve2DNMSE(int startSlice, int endSlice)
- convolve3D
  
  private final void convolve3D(int start, int end, float[] iImage, int index)
- convolve3DBilateral
  
  private final void convolve3DBilateral(int start, int end, float[] iImage, int index)
- convolve2D3D
  
  private final void convolve2D3D(int start, int end, float[] iImage, int index, int min3DLength, int max3DLength)
- convolve3DXYZ
  
  private final void convolve3DXYZ(int start, int end, float[] iImage, int index)
- convolve3DNMS
  
  private final void convolve3DNMS(int start, int end, float[] iImage, int index)
- convolve3DNMSE
  
  private final void convolve3DNMSE(int start, int end, float[] iImage, int index)
- finalize
  
  public void finalize()
  
  Prepares this class for destruction.
  
  Overrides:
  
  finalize in class AlgorithmBase
- run2D
  
  public void run2D()
  
  Begins the execution of the 2D convolver.
- run3D
  
  public void run3D()
  
  Begins the execution of the 3D convolver.
- run4D
  
  public void run4D()
- runAlgorithm
  
  public void runAlgorithm()
  
  Begins execution of the convolver.
  
  Specified by:
  
  runAlgorithm in class AlgorithmBase
- getBilinear
  
  private static float getBilinear(int i, float dx, float dy, int[] iExtents, float[] image)
  
  Performs bilinear interpolation of image data.
  
  Parameters:
  
  i - index into image
  
  dx - change in x from integer
  
  dy - change in y from integer
  
  iExtents - dimensions of image
  
  image - image data
  
  Returns:
  
  the bilinearly interpolated value
- getBilinear
  
  private static double getBilinear(int i, double dx, double dy, int[] iExtents, double[] image)
  
  Performs bilinear interpolation of image data.
  
  Parameters:
  
  i - index into image
  
  dx - change in x from integer
  
  dy - change in y from integer
  
  iExtents - dimensions of image
  
  image - image data
  
  Returns:
  
  the bilinearly interpolated value
- getTrilinear
  
  private static float getTrilinear(int i1, float dx, float dy, float dz, int[] iExtents, float[] image)
  
  Performs trilinear interpolation of image data.
  
  Parameters:
  
  i1 - index into image
  
  dx - change in x from integer
  
  dy - change in y from integer
  
  dz - change in z from integer
  
  iExtents - dimensions of image
  
  image - image data
  
  Returns:
  
  the trilinearly interpolated data value
- getTrilinearC
  
  public static byte[] getTrilinearC(int i1, float dx, float dy, float dz, int[] iExtents, byte[] image)
  
  Performs trilinear interpolation of image data.
  
  Parameters:
  
  i1 - index into image
  
  dx - change in x from integer
  
  dy - change in y from integer
  
  dz - change in z from integer
  
  iExtents - dimensions of image
  
  image - image data
  
  Returns:
  
  the trilinearly interpolated data value
- getOutputBuffer
  
  public float[] getOutputBuffer()
  
  Returns the output buffer
  
  Returns:
  
  buffer that contains the data after convolution

Class AlgorithmConvolver

Nested Class Summary

Nested classes/interfaces inherited from class java.lang.Thread

Field Summary

Fields inherited from class gov.nih.mipav.model.algorithms.AlgorithmBase

Fields inherited from class java.lang.Thread

Constructor Summary

Method Summary

Methods inherited from class gov.nih.mipav.model.algorithms.AlgorithmBase

Methods inherited from class java.lang.Thread

Methods inherited from class java.lang.Object

Field Details

kExtents

kernelBuffer

kernelBufferX

kernelBufferY

kernelBufferZ

kernelBufferX2

kernelBufferY2

kernelBufferXX

kernelBufferXY

kernelBufferYY

kernelBufferXZ

kernelBufferYZ

kernelBufferZZ

kernelBufferXXX

kernelBufferXXY

kernelBufferXYY

kernelBufferYYY

kernelBufferXXZ

kernelBufferXZZ

kernelBufferXYZ

kernelBufferYYZ

kernelBufferYZZ

kernelBufferZZZ

red

blue

green

outputBuffer

entireImage

doXY

sqrtXY

sqrtXYZ

nms2

nms2e

nms3

nms3e

combined2D3D

intensityGaussianDenom

bilateral

Constructor Details

AlgorithmConvolver

AlgorithmConvolver

AlgorithmConvolver

AlgorithmConvolver

AlgorithmConvolver

AlgorithmConvolver

AlgorithmConvolver

AlgorithmConvolver

AlgorithmConvolver

Method Details

isRed

setRed

isBlue

setBlue

isGreen

setGreen

setColorChannels

convolve2DPt

convolveBilateral2DPt

convolve2DPtSqrtXY

convolve2DPtNMS

convolve2DPtNMSE

convolve2DPt

convolve2DPt

convolve2DPtMed

convolve2DRGBPt

convolveBilateral2DCIELabPt

convolve2DRGBPtSqrtXY

convolve3DPt