# Created by Octave 3.4.0, Fri Apr 29 21:00:13 2011 UTC <mockbuild@ppc-comm01>
# 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: 757
 -- Function File: [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 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

 -- Function File: [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: 641
 -- Function File: [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: 7
deriche


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 811
 -- Loadable Function: B = deriche(A, N, M)
     Return edge detector image of A image according to an algorithm by
     Rachid Deriche.  Matrix A is a real matrix, and N a non-negative
     real kernel scaling parameter (default 1.0). Specify M = 0 for a
     gradient magnitude result (default), M = 1 for a vector gradient
     result.  N and M are optional arguments.

     Processing time is independent on N.  see for details: Klette,
     Zameroni: Handbuch der Operatoren fuer die Bildverarbeitung,
     vieweg 2. ed. 1995 pp. 224-229.  Original paper: Deriche, R.: Fast
     algorithms for low-level vision: IEEE Trans PAMI-12 (1990) pp
     78-87.

     Example:
           a = double(imread('myimg.png'));
           b = deriche(a, 1.0, 1);
           imshow(b(:,:,1));
           imshow(b(:,:,2));




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Return edge detector image of A image according to an algorithm by
Rachid Derich



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 602
 -- Function File: 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: 364
 -- 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: 608
 -- Function File: 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).

 -- Function File: 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: 804
 -- Function File: 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





