# Created by Octave 3.6.4, Fri Mar 01 14:06:51 2013 MST <mockbuild@ppc-builder1.qa.fedoraproject.org>
# name: cache
# type: cell
# rows: 3
# columns: 7
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
bwfill


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 783
 -- Loadable Function: [BW2, IDX] = bwfill( BW1, C, R, N)
     Perform a flood-fill operation on the binary image BW1.  The
     flood-filling starts in the pixel (R, C).  If R and C are vectors
     of the same length, each pixel pair (R(i), C(i)) will be a starting
     point for a flood-fill operation.  The argument N changes the
     neighborhood connectivity (of the holes) for the flood-fill
     operation.  N can be either 4 or 8, and has a default value of 8.

     The output is the processed image BW2 and the indexes of the filled
     pixels IDX
 -- Loadable Function: [BW2, IDX] = bwfill( BW1, "holes", N)
     If the string "holes" is given instead of starting points for the
     flood-fill operation, the function finds interior holes in BW1 and
     fills them.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Perform a flood-fill operation on the binary image BW1.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
bwlabel


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 646
 -- Loadable Function: [L, NUM] = bwlabel( BW, N)
     Labels foreground objects in the binary image BW.  The output L is
     a matrix where 0 indicates a background pixel, 1 indicates that the
     pixel belong to object number 1, 2 that the pixel belong to object
     number 2, etc.  The total number of objects is NUM.

     To pixels belong to the same object if the are neighbors.  By
     default the algorithm uses 8-connectivity to define a neighborhood,
     but this can be changed through the argument N that can be either
     4, 6, or 8.

     The algorithm is derived from BKP Horn, Robot Vision, MIT Press,
     1986, p 65 - 89




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Labels foreground objects in the binary image BW.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
bwlabeln


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 881
 -- Loadable Function: [L, NUM] = bwlabeln( BW)
 -- Loadable Function: [L, NUM] = bwlabeln( BW, N)
     Label foreground objects in the n-dimensional binary image BW.

     The optional argument N sets the connectivity and defaults 26, for
     26-connectivity in 3-D images.  Other possible values are 18 and 6
     for 3-D images, 4 and 8 for 2-D images, or an arbitrary
     N-dimensional binary connectivity mask where each dimension is of
     size 3.

     The output L is an Nd-array where 0 indicates a background pixel, 1
     indicates that the pixel belong to object number 1, 2 that the
     pixel belong to object number 2, etc.  The total number of objects
     is NUM.

     The algorithm used is a disjoint-set data structure, a.k.a.
     union-find.  See, for example,
     http://en.wikipedia.org/wiki/Union-find

     See also: bwconncomp, bwlabel, regionprops




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Label foreground objects in the n-dimensional binary image BW.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
graycomatrix


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 609
 -- Loadable Function: P = graycomatrix( IM, LEVELS, DISTANCES, ANGLES)
     Calculates the gray-level co-occurrence matrix P of a gray-level
     image IM.

     P is a 4-dimensional matrix (histogram).  The value P(I,J,D,THETA)
     is the number of times that gray-level J occurs at a distance D and
     at an angle THETA from gray-level I.

     IM is the input image which should contain integers in [0,
     LEVELS-1], where LEVELS indicate the number of gray-levels counted
     (typically 256 for an 8-bit image).  DISTANCES and ANGLES are
     vectors of the different distances and angles to use.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
Calculates the gray-level co-occurrence matrix P of a gray-level image
IM.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
hough_line


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 366
 -- Loadable Function: [H, R] = hough_line( I, ANGLES)
     Calculate the straight line Hough transform of a binary image I.

     The angles are given in degrees and defaults to -90:90.

     H is the resulting Hough transform, and R is the radial distances.

     The algorithm is described in Digital Image Processing by Gonzales
     & Woods (2nd ed., p.  587)




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Calculate the straight line Hough transform of a binary image I.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
nonmax_supress


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 619
 -- Loadable Function: nonmax_supress ( ES, EO)
     Performs non-maximum supression on the given edge data.  ES is a
     matrix containing the edge strength (the length of the gradient),
     and EO is the edge normal orientation (the direction of the
     gradient).

 -- Loadable Function: nonmax_supress ( ES, EO, LOW, HIGH )
     Performs non-maximum supression and hysteresis thresholdong, using
     LOW and HIGH as thresholds.

     This function is designed to be used as part of the Canny edge
     detection, and not to be used in general.  So if you use this
     function: Beware...

     See also: edge




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Performs non-maximum supression on the given edge data.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
rotate_scale


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 809
 -- Loadable Function: IM1 = rotate_scale( IM0, LM0, LM1, OUT_SIZE)
     Arbitrary rotation and scaling of a gray-scale image using fast
     bilinear interpolation.

     The image IM0 will be rotated and scaled such that the landmark
     points in LM0 in the image will be placed in the landmark points in
     LM1 in the output image IM1.  The landmark points are given as a 2
     by 2 matrix where the first row contains the x-coordinates of the
     landmarks, and the second row contains the y-coordinates.

     The size of the output image is given in the vector OUT_SIZE.

     The following example shows basic usage of the function
          im0 = zeros(100); im0(25:75, 25:75)=1;
          im1 = rotate_scale( im0, [40,60; 50,50], [60,90; 60,90], [120,120]);

     See also: imrotate, imresize




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Arbitrary rotation and scaling of a gray-scale image using fast bilinear
interpo





