Overview  Package   Class  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

gov.nih.mipav.model.algorithms
Class AlgorithmConvolver

java.lang.Object
  extended by java.lang.Thread
      extended by gov.nih.mipav.model.algorithms.AlgorithmBase
          extended by 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()).

  1. Source image is exported (locked and unlocked by export)
  2. Kernel is exported
  3. Image is convolved with kernel
  4. 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.State, Thread.UncaughtExceptionHandler
 
Field Summary
 
Fields inherited from class gov.nih.mipav.model.algorithms.AlgorithmBase
destFlag, destImage, image25D, mask, maxProgressValue, minProgressValue, multiThreadingEnabled, nthreads, progress, progressModulus, progressStep, runningInSeparateThread, srcImage, threadStopped
 
Fields inherited from class java.lang.Thread
MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY
 
Constructor Summary
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)
           
AlgorithmConvolver(ModelImage srcImg, ModelImage kern)
          Sets the source and kernel images and calls the appropriate method based on image dimensionality.
 
Method Summary
static 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 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 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 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 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 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 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 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.
static 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 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 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 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 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 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 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 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.
static void convolveBlock3D(int start, int end, int lpv, float[] iImage, int[] iExtents, int[] kExtents, float[] kernel, ModelImage oImage)
           
static 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 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.
 float[] getOutputBuffer()
           
 boolean isBlue()
           
 boolean isGreen()
           
 boolean isRed()
           
 void run2D()
          Begins the excution of the 2D convolver.
 void run3D()
          Begins the excution 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 setKernelImage(ModelImage kern)
          Accessor that sets the and kernel image.
 void setRed(boolean red)
           
 
Methods inherited from class gov.nih.mipav.model.algorithms.AlgorithmBase
actionPerformed, addListener, addProgressChangeListener, calculatePrincipleAxis, computeElapsedTime, convertIntoFloat, delinkProgressToAlgorithm, displayError, errorCleanUp, fireProgressStateChanged, fireProgressStateChanged, fireProgressStateChanged, fireProgressStateChanged, fireProgressStateChanged, generateProgressValues, getDestImage, getElapsedTime, getMask, getMaxProgressValue, getMinProgressValue, getNumberOfThreads, getProgress, getProgressChangeListener, getProgressChangeListeners, getProgressModulus, getProgressStep, getProgressValues, isCompleted, isImage25D, isMultiThreadingEnabled, isRunningInSeparateThread, isThreadStopped, linkProgressToAlgorithm, makeProgress, notifyListeners, removeListener, removeProgressChangeListener, run, setCompleted, setImage25D, setMask, setMaxProgressValue, setMinProgressValue, setMultiThreadingEnabled, setNumberOfThreads, setProgress, setProgressModulus, setProgressStep, setProgressValues, setProgressValues, setRunningInSeparateThread, setStartTime, setThreadStopped, startMethod, windowActivated, windowClosed, windowClosing, windowDeactivated, windowDeiconified, windowIconified, windowOpened
 
Methods inherited from class java.lang.Thread
activeCount, checkAccess, countStackFrames, currentThread, destroy, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, join, join, join, resume, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, start, stop, stop, suspend, toString, yield
 
Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
 

Constructor Detail

AlgorithmConvolver

public AlgorithmConvolver(ModelImage srcImg,
                          ModelImage kern)
Sets the source and kernel images and calls the appropriate method based on image dimensionality.

Parameters:
srcImg - Source image to be convolved with kernel.
kern - Kernel image.

AlgorithmConvolver

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

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 Detail

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

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

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

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

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 -
lpp - length per voxel, for example 4 for RGB image.
iImage -
iExtents -
kExtents -
kernel -
oImage -

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

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

finalize

public void finalize()
Prepares this class for destruction.

Overrides:
finalize in class AlgorithmBase

run2D

public void run2D()
Begins the excution of the 2D convolver.

run3D

public void run3D()
Begins the excution of the 3D convolver.

run4D

public void run4D()

runAlgorithm

public void runAlgorithm()
Begins execution of the convolver.

Specified by:
runAlgorithm in class AlgorithmBase

setKernelImage

public void setKernelImage(ModelImage kern)
Accessor that sets the and kernel image.

Parameters:
kern - Kernel image.

getOutputBuffer

public float[] getOutputBuffer()
Overview  Package   Class  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD