# Created by Octave 3.8.2, Mon Nov 03 03:19:09 2014 UTC <mockbuild@buildhw-09.phx2.fedoraproject.org>
# name: cache
# type: cell
# rows: 3
# columns: 8
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
bwdist


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 901
 -- Loadable Function: DIST = bwdist (BW)
 -- Loadable Function: DIST = bwdist (BW, METHOD)
 -- Loadable Function: [DIST, IDX] = bwdist (...)
     Compute distance transform in binary image.

     The image BW must be a binary matrix For MATLAB compatibility, no
     check is performed, all non-zero values are considered object
     pixels.  The return value DIST, is the distance of each background
     pixel to the closest object pixel in a matrix of class 'single'.

     IDX is the linear index for the closest object, used to calculate
     the distance for each of the pixels.  Its class is dependent on the
     number of elements in BW, 'uint64' if less than 2^32 elements,
     'uint32' otherwise.

     The distance can be measured through different METHODs:

     euclidean (default)

     chessboard

     cityblock

     quasi-euclidean

     Currently, only 2D images are supported.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Compute distance transform in binary image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
bwfill


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 784
 -- 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: 8
bwlabeln


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 882
 -- 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: 7
imerode


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1029
 -- Loadable Function: imerode (IM, SE)
 -- Loadable Function: imerode (IM, SE, SHAPE)
     Perform morphological erosion.

     The image IM must be a numeric matrix with any number of
     dimensions.  The erosion is performed with the structuring element
     SE which can be a:

        * strel object;
        * array of strel objects as returned by '@strel/getsequence';
        * matrix of 0's and 1's.

     To perform a non-flat erosion, SE must be a strel object.

     The size of the result is determined by the optional SHAPE argument
     which takes the following values:

     "same" (default)
          Return image of the same size as input IM.

     "full"
          Return the full erosion (image is padded to accommodate SE
          near the borders).

     "valid"
          Return only the parts which do not include the padded edges.

     In case of a SE with a size of even length, the center is
     considered at indices 'floor ([size(SE)/2] + 1)'.

     See also: imdilate, imopen, imclose, strel.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Perform morphological erosion.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 618
 -- 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: 810
 -- 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





