Class AlgorithmSnake

All Implemented Interfaces:
ActionListener, WindowListener, Runnable, EventListener

public class AlgorithmSnake extends AlgorithmBase
Snake-like algorithm deriviative. The algorithm is supplied a polygon (VOI - contour) and that polygon is allowed to evolve to the edge of the object generated by calculating the gradient magnitude (i.e. the energy function) at scale define by the user. The user/programmer supplies the sigmas (scales) at which to calculate the gradient magnitude. A large scale slows the snake and causes the snake to conform to large scale structure. A small sigma value causes the snake to conform to the small scale structure is therefore more sensitive to noise. The three-dimensional version is really a two-and-half dimensional algorithm where the resultant contour in a slice is projected into the adjacent slice and is used as an initialization to the evolution in the new slice.
Version:
0.1 Feb 11, 1998
Author:
Matthew J. McAuliffe, Ph.D.
See Also:
  • Field Details

    • PROP_SINGLE

      public static final int PROP_SINGLE
      Do not propagate the VOI to any slices (2D).
      See Also:
    • PROP_NEXT

      public static final int PROP_NEXT
      Propagate the source VOI to slices above its current slice in the volume.
      See Also:
    • PROP_PREV

      public static final int PROP_PREV
      Propagate the source VOI to slices below its current slice in the volume.
      See Also:
    • PROP_ALL

      public static final int PROP_ALL
      Propagate the source VOI to slices above and below its current slice.
      See Also:
    • ANY_DIR

      public static final int ANY_DIR
      Indicates boundary can move in or out.
      See Also:
    • IN_DIR

      public static final int IN_DIR
      Indicates boundary can move in.
      See Also:
    • OUT_DIR

      public static final int OUT_DIR
      Indicates boundary can move out.
      See Also:
    • PROP_THRESHOLD

      private static final float PROP_THRESHOLD
      The maximum ratio of change in the energy under the VOI after propagation.
      See Also:
    • boundaryIterations

      private int boundaryIterations
      Maximum number of snake iterations.
    • evolveDirection

      private int evolveDirection
      Indicates boundary how the VOI boundary can move - in and/or out.
    • GxData

      private float[] GxData
      Storage location of the first derivative of the Gaussian in the X direction.
    • GyData

      private float[] GyData
      Storage location of the first derivative of the Gaussian in the Y direction.
    • GzData

      private float[] GzData
      Storage location of the first derivative of the Gaussian in the Z direction.
    • kExtents

      private int[] kExtents
      Dimensionality of the kernel.
    • propagationType

      private int propagationType
      The VOI propagation mode to use.
    • resultVOI

      private VOI resultVOI
      The resultant polygon and the evolution has completed.
    • sigmas

      private float[] sigmas
      Standard deviations of the gaussian used to calculate the kernels.
    • smoothness

      private float smoothness
      The maximum angle we want to have between points in the result VOI.
    • srcImage

      private ModelImage srcImage
      Source image.
    • srcVOI

      private VOI srcVOI
      The initial VOI to initialize the evolution process.
  • Constructor Details

    • AlgorithmSnake

      public AlgorithmSnake(ModelImage _srcImg, float[] _sigmas, int _boundaryIterations, float _smoothness, VOI srcVOI, int boundDir)
      Set up the snake algorithm so that it can be run.
      Parameters:
      _srcImg - 2D or 3D source image
      _sigmas - describe the scale of the gaussian in each dimension
      _boundaryIterations - maximum number of snake iterations
      _smoothness - the boundary smoothness parameter
      srcVOI - VOI that is to be evolved
      boundDir - indicates the boundary direction (in and/or out)
  • Method Details

    • finalize

      public void finalize()
      Prepares this class for destruction.
      Overrides:
      finalize in class AlgorithmBase
    • getResultVOI

      public VOI getResultVOI()
      Returns the resultant VOI.
      Returns:
      resultant VOI that has localized to the boundaries of the object
    • runAlgorithm

      public void runAlgorithm()
      run - starts the snake algorithm.
      Specified by:
      runAlgorithm in class AlgorithmBase
    • setPropagation

      public void setPropagation(int type)
      Sets the propagation type.
      Parameters:
      type - if PROP_ALL, result contour from a slice is propagated to the adjacent slice and used to initialize the snake algorithm for that slice. If PROP_NEXT, result contour from the original slice is propagated to the next slice and used to initialize the snake algorithm for that slice. If PROP_PREV, result contour from the orginal slice is propagated to the previous slice. If PROP_SINGLE, the snake algorithm stops after optimizing the boundary in the present slice.
    • calc2D

      private void calc2D()
      Prepares the data and runs the algorithm for a 2D image.
    • calc3D

      private void calc3D()
      Prepares the data and runs the algorithm for a 3D image.
    • cleanLine

      private Vector<WildMagic.LibFoundation.Mathematics.Vector2f> cleanLine(float[] xPts, float[] yPts)
      Removes points (vectors) that form sharp angles (i.e. smoothes boudnary) Also adds points separated by some distance and removes adjacent points
      Parameters:
      xPts - x coords of points that define a contour
      yPts - y coords of points that define a contour
      Returns:
      an ordered list of the points along the cleaned-up line
    • cleanLine

      private Vector<WildMagic.LibFoundation.Mathematics.Vector3f> cleanLine(float[] xPts, float[] yPts, float[] zPts)
    • distance

      private double distance(int x1, int x2, int y1, int y2)
      Calculates the euclidian distance between two points.
      Parameters:
      x1 - first x coord.
      x2 - seconde x coord.
      y1 - first y1 coord.
      y2 - seconde y2 coord.
      Returns:
      the distance between the points (x1,y1) and (x2,y2)
    • distance

      private double distance(float x1, float x2, float y1, float y2)
      Calculates the euclidian distance between two points.
      Parameters:
      x1 - first x coord.
      x2 - seconde x coord.
      y1 - first y1 coord.
      y2 - seconde y2 coord.
      Returns:
      the distance between the points (x1,y1) and (x2,y2)
    • makeKernels2D

      private void makeKernels2D()
      Makes derivative kernels to be used in the calculation of the gradient magnitude.
    • makeKernels3D

      private void makeKernels3D()
      Makes derivative kernels to be used in the calculation of the gradient magnitude.
    • runSnake

      private float runSnake(float[] xPoints, float[] yPoints, float[] image, Polygon resultGon)
      Actual function that evolves the boundary by moving normal to the boundary.
      Parameters:
      xPoints - x coordinates that describe the contour
      yPoints - y coordinates that describe the contour
      image - image data
      resultGon - resultant polygon
      Returns:
      the sum of the energy along the boundary of the resultGon
    • runSnake

      private float runSnake(float[] xPoints, float[] yPoints, float[] zPoints, float[] image, VOIBase contour)
    • propDown

      private void propDown(VOIContour resultContour, VOI resultVOI, float baseEnergy, int baseNPts)
    • propUp

      private void propUp(VOIContour resultContour, VOI resultVOI, float baseEnergy, int baseNPts)
    • setPoints

      private void setPoints(float[] xPoints, float[] yPoints, Polygon gon)
      Takes the polygon and forms two special arrays for use in runSnake.
      Parameters:
      xPoints - storage location of array of x coord. points
      yPoints - storage location array of y coord. points
      gon - initial polygon
    • setPoints

      private void setPoints(float[] xPoints, float[] yPoints, float[] zPoints, VOIBase contour)