octave-image 2.2.2-1 / usr / share / octave / packages / image-2.2.2 / doc-cache

# Created by Octave 3.8.2, Mon Oct 20 21:24:38 2014 UTC <root@rama>
# name: cache
# type: cell
# rows: 3
# columns: 121
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
analyze75info


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 572
 -- Function File: HEADER = analyze75info (FILENAME)
 -- Function File: HEADER = analyze75info (FILENAME, "ByteOrder", ARCH)
     Read header of an Analyze 7.5 file.

     FILENAME must be the path for an Analyze 7.5 file or the path for a
     directory with a single .hdr file can be specified.

     The optional argument '"ByteOrder"' reads the file with the
     specified ARCH ("ieee-be" or "ieee-le" for IEEE big endian or IEEE
     little endian respectively).

     HEADER is a structure with the file information.

     See also: analyze75read, analyze75write.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
Read header of an Analyze 7.5 file.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
analyze75read


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 412
 -- Function File: IMAGE = analyze75read (FILENAME)
 -- Function File: IMAGE = analyze75read (HEADER)
     Read image data of an Analyze 7.5 file.

     FILENAME must be the path for an Analyze 7.5 file or the path for a
     directory with a single .hdr file can be specified.  Alternatively,
     the file HEADER can be specified as returned by 'analyze75info'.

     See also: analyze75info, analyze75write.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Read image data of an Analyze 7.5 file.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 507
 -- Function File: analyze75write ( FILENAME, DATA, HEADER)
 -- Function File: analyze75write ( FILENAME, DATA, X, Y, Z)
 -- Function File: analyze75write ( FILENAME, DATA, HEADER, X, Y, Z)
     Write image data to an Analyze 7.5 file.

     FILENAME is the path to write the Analyze 7.5 file; DATA is the 3D
     image data; HEADER is a structure containing the file information;
     X, Y, Z are lists of the x,y,z coordinates (in cm) of the data
     grid.

     See also: analyze75info, analyze75read.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
Write image data to an Analyze 7.5 file.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 556
 -- Function File: A = applylut (BW, LUT)
     Uses lookup tables to perform a neighbour operation on binary
     images.

     A = applylut(BW,LUT) returns the result of a neighbour operation
     using the lookup table LUT which can be created by makelut.

     It first computes a matrix with the index of each element in the
     lookup table.  To do this, it convolves the original matrix with a
     matrix which assigns each of the neighbours a bit in the resulting
     index.  Then LUT is accessed to compute the result.

     See also: makelut.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
Uses lookup tables to perform a neighbour operation on binary images.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 916
 -- Function File: BLK_SIZE = bestblk (IMS)
 -- Function File: BLK_SIZE = bestblk (IMS, MAX)
 -- Function File: [MB, NB, ...] = bestblk (...)
     Calculate block best size for block processing.

     Given a matrix of size IMS, calculates the largest size for
     distinct blocks BLK_SIZE, that minimize padding and is smaller than
     or equal to K (defaults to 100)

     The output BLK_SIZE is a row vector for the block size.  If there
     are multiple output arguments, the number of rows is assigned to
     the first (MB), and the number of columns to the second (NB), etc.

     To determine BLK_SIZE, the following is performed for each
     dimension:

       1. If dimension IMS is less or equal than K, it returns the
          dimension value.

       2. If not, find the highest value between 'min (dimension/10,
          k/2)' which minimizes padding.

     See also: blockproc, col2im, im2col.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Calculate block best size for block processing.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
blockproc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1459
 -- Function File: B = blockproc (A, [M,N], FUN)
 -- Function File: B = blockproc (A, [M,N], FUN, ...)
 -- Function File: B = blockproc (A, [M,N], [MBORDER,NBORDER], FUN, ...)
 -- Function File: B = blockproc (A, 'indexed', ...)
     Processes image in blocks using user-supplied function.

     'B=blockproc(A,[m,n],fun)' divides image A in M-by-N blocks, and
     passes them to user-supplied function FUN, which result is
     concatenated to build returning matrix B.  If padding is needed to
     build M-by-N, it is added at the bottom and right borders of the
     image.  0 is used as a padding value.

     'B=blockproc(A,[m,n],fun, ...)' behaves as described above but
     passes extra parameters to function FUN.

     'B=blockproc(A,[m,n],[mborder,nborder],fun, ...)' behaves as
     described but uses blocks which overlap with neighbour blocks.
     Overlapping dimensions are MBORDER vertically and NBORDER
     horizontally.  This doesn't change the number of blocks in an image
     (which depends only on size(A) and [M,N]).  Adding a border
     requires extra padding on all edges of the image.  0 is used as a
     padding value.

     'B=blockproc(A,'indexed', ...)' assumes that A is an indexed image,
     so it pads the image using proper value: 0 for uint8 and uint16
     images and 1 for double images.  Keep in mind that if 'indexed' is
     not specified padding is always done using 0.

     See also: colfilt,inline,bestblk.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Processes image in blocks using user-supplied function.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 536
 -- Function File: TOTAL = bwarea (BW)
     Estimate total area of objects on the image BW.

     The image BW can be of any class, even non-logical, in which case
     non zero valued pixels are considered to be an object.

     This algorithm is not the same as counting the number of pixels
     belonging to an object as it tries to estimate the area of the
     original object.  The value of each pixel to the total area is
     weighted in relation to its neighbour pixels.

     See also: im2bw, bweuler, bwperim, regionprops.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Estimate total area of objects on the image BW.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 711
 -- Function File: bwareaopen (BW, LIM)
 -- Function File: bwareaopen (BW, LIM, CONN)
     Perform area opening.

     Remove objects with less than LIM elements from a binary image BW.

     Element connectivity CONN, to define the size of objects, can be
     specified with a numeric scalar (number of elements in the
     neighborhood):

     '4 or 8'
          for 2 dimensional matrices;
     '6, 18 or 26'
          for 3 dimensional matrices;

     or with a binary matrix representing a connectivity array.
     Defaults to 'conndef (ndims (BW), "maximal")' which is equivalent
     to CONN of 8 and 26 for 2 and 3 dimensional matrices respectively.

     See also: bwconncomp, conndef, bwboundaries.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
Perform area opening.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 448
 -- Function File: B = bwborder (IM)
     Finds the borders of foreground objects in a binary image.

     'bwborder' has been deprecated in favor of 'bwmorph (IM,"remove")'.
     This function will be removed from future versions of the 'image'
     package.

     B is the borders in the 0-1 matrix IM.  4-neighborhood is
     considered.

     A pixel is on the border if it is set in IM, and it has at least
     one neighbor that is not set.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Finds the borders of foreground objects in a binary image.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1284
 -- Function File: BOUNDARIES = bwboundaries( BW)
 -- Function File: BOUNDARIES = bwboundaries( BW, CONN)
 -- Function File: BOUNDARIES = bwboundaries( BW, CONN, HOLES)
 -- Function File: [BOUNDARIES, LABELS] = bwboundaries( ...)
 -- Function File: [BOUNDARIES, LABELS, NUM_LABELS] = bwboundaries( ...)
     Trace the boundaries of the objects in a binary image.

     BOUNDARIES is a cell array in which each element is the boundary of
     an object in the binary image BW.  The clockwise boundary of each
     object is computed by the 'boundary' function.

     By default the boundaries are computed using 8-connectivity.  This
     can be changed to 4-connectivity by setting CONN to 4.

     By default 'bwboundaries' computes all boundaries in the image,
     i.e.  both interior and exterior object boundaries.  This behaviour
     can be changed through the HOLES input argument.  If this is
     'holes', both boundary types are considered.  If it is instead
     'noholes', only exterior boundaries will be traced.

     If two or more output arguments are requested, the algorithm also
     returns the labelled image computed by 'bwlabel' in LABELS.  The
     number of labels in this image is optionally returned in
     NUM_LABELS.

     See also: boundary, bwlabel.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Trace the boundaries of the objects in a binary image.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1513
 -- Function File: CC = bwconncomp (BW)
 -- Function File: CC = bwconncomp (BW, CONN)
     Find connected objects.

     Elements from the matrix BW, belong to an object if they have a
     non-zero value.  The output CC is a structure with information
     about each object;

     "Connectivity"
          The connectivity used in the boundary tracing.  This may be
          different from the input argument, e.g., if CONN is defined as
          a matrix of 1s and size 3x3, the "Connectivity" value will
          still be 8.

     "ImageSize"
          The size of the matrix BW.

     "NumObjects"
          The number of objects in the image BW.

     "PixelIdxList"
          A cell array with linear indices for each element of each
          object in BW A cell array containing where each element
          corresponds to an object in BW.  Each element is represented
          as a vector of linear indices of the boundary of the given
          object.

     Element connectivity CONN, to define the size of objects, can be
     specified with a numeric scalar (number of elements in the
     neighborhood):

     '4 or 8'
          for 2 dimensional matrices;
     '6, 18 or 26'
          for 3 dimensional matrices;

     or with a binary matrix representing a connectivity array.
     Defaults to 'conndef (ndims (BW), "maximal")' which is equivalent
     to CONN of 8 and 26 for 2 and 3 dimensional matrices respectively.

     See also: bwlabel, bwlabeln, bwboundaries, ind2sub, regionprops.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
Find connected objects.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 663
 -- Function File: EUL = bweuler (BW, N)
     Calculate the Euler number of a binary image.

     This function calculates the Euler number EUL of a binary image BW.
     This number is a scalar whose value represents the total number of
     objects in BW minus the number of holes.

     N is an optional argument that specifies the neighbourhood
     connectivity.  Must either be 4 or 8.  If omitted, defaults to 8.

     This function uses Bit Quads as described in "Digital Image
     Processing" to calculate euler number.

     References: W. K. Pratt, "Digital Image Processing", 3rd Edition,
     pp 593-595

     See also: bwmorph, bwperim, qtgetblk.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Calculate the Euler number of a binary image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
bwhitmiss


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 535
 -- Function File: BW2 = bwhitmiss (BW1, SE1, SE1)
 -- Function File: BW2 = bwhitmiss (BW1, INTERVAL)
     Perform the binary hit-miss operation.

     If two structuring elements SE1 and SE1 are given, the hit-miss
     operation is defined as
          bw2 = erode(bw1, se1) & erode(!bw1, se2);
     If instead an 'interval' array is given, two structuring elements
     are computed as
          se1 = (interval ==  1)
          se2 = (interval == -1)
     and then the operation is defined as previously.

     See also: bwmorph.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Perform the binary hit-miss operation.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7803
 -- Function File: bwmorph (BW, OPERATION)
 -- Function File: bwmorph (BW, OPERATION, N)
     Perform morphological operation on binary image.

     For a binary image BW, performs the morphological OPERATION, N
     times.  All possible values of OPERATION are listed on the table
     below.  By default, N is 1.  If N is 'Inf', the operation is
     continually performed until it no longer changes the image.

     In some operations, BW can be a binary matrix with any number of
     dimensions (see details on the table of operations).

     Note that the output will always be of class logical, independently
     of the class of BW.

     'bothat'
          Performs a bottom hat operation, a closing operation (which is
          a dilation followed by an erosion) and finally substracts the
          original image (see 'imbothat').  BW can have any number of
          dimensions, and 'strel ("hypercube", ndims (BW), 3)' is used
          as structuring element.

     'bridge'
          Performs a bridge operation.  Sets a pixel to 1 if it has two
          nonzero neighbours which are not connected, so it "bridges"
          them.  There are 119 3-by-3 patterns which trigger setting a
          pixel to 1.

     'clean'
          Performs an isolated pixel remove operation.  Sets a pixel to
          0 if all of its eight-connected neighbours are 0.  BW can have
          any number of dimensions in which case connectivity is
          '(3^ndims(BW)) -1', i.e., all of the elements around it.

     'close'
          Performs closing operation, which is a dilation followed by
          erosion (see 'imclose').  BW can have any number of
          dimensions, and 'strel ("hypercube", ndims (BW), 3)' is used
          as structuring element.

     'diag'
          Performs a diagonal fill operation.  Sets a pixel to 1 if that
          eliminates eight-connectivity of the background.

     'dilate'
          Performs a dilation operation (see 'imdilate').  BW can have
          any number of dimensions, and 'strel ("hypercube", ndims (BW),
          3)' is used as structuring element.

     'erode'
          Performs an erosion operation (see 'imerode').  BW can have
          any number of dimensions, and 'strel ("hypercube", ndims (BW),
          3)' is used as structuring element.

     'fill'
          Performs a interior fill operation.  Sets a pixel to 1 if all
          four-connected pixels are 1.  BW can have any number of
          dimensions in which case connectivity is '(2*ndims(BW))'.

     'hbreak'
          Performs a H-break operation.  Breaks (sets to 0) pixels that
          are H-connected.

     'majority'
          Performs a majority black operation.  Sets a pixel to 1 if the
          majority of the pixels (5 or more for a two dimensional image)
          in a 3-by-3 window is 1.  If not set to 0.  BW can have any
          number of dimensions in which case the window has dimensions
          'repmat (3, 1, ndims (BW))'.

     'open'
          Performs an opening operation, which is an erosion followed by
          a dilation (see 'imopen').  BW can have any number of
          dimensions, and 'strel ("hypercube", ndims (BW), 3)' is used
          as structuring element.

     'remove'
          Performs a iterior pixel remove operation.  Sets a pixel to 0
          if all of its four-connected neighbours are 1.  BW can have
          any number of dimensions in which case connectivity is
          '(2*ndims(BW))'.

     'shrink'
          Performs a shrink operation.  Sets pixels to 0 such that an
          object without holes erodes to a single pixel (set to 1) at or
          near its center of mass.  An object with holes erodes to a
          connected ring lying midway between each hole and its nearest
          outer boundary.  It preserves Euler number.

     'skel'
          Performs a skeletonization operation.  It calculates a "median
          axis skeleton" so that points of this skeleton are at the same
          distance of its nearby borders.  It preserver Euler number.
          Please read compatibility notes for more info.

          It uses the same algorithm as skel-pratt but this could change
          for compatibility in the future.

     'skel-lantuejol'
          Performs a skeletonization operation as described in Gonzalez
          & Woods "Digital Image Processing" pp 538-540.  The text
          references Lantuejoul as authour of this algorithm.

          It has the beauty of being a clean and simple approach, but
          skeletons are thicker than they need to and, in addition, not
          guaranteed to be connected.

          This algorithm is iterative.  It will be applied the minimum
          value of N times or number of iterations specified in
          algorithm description.  It's most useful to run this algorithm
          with 'n=Inf'.

          BW can have any number of dimensions.

     'skel-pratt'
          Performs a skeletonization operation as described by William
          K. Pratt in "Digital Image Processing".

     'spur'
          Performs a remove spur operation.  It sets pixel to 0 if it
          has only one eight-connected pixel in its neighbourhood.

     'thicken'
          Performs a thickening operation.  This operation "thickens"
          objects avoiding their fusion.  Its implemented as a thinning
          of the background.  That is, thinning on negated image.
          Finally a diagonal fill operation is performed to avoid
          "eight-connecting" objects.

     'thin'
          Performs a thinning operation.  When n=Inf, thinning sets
          pixels to 0 such that an object without holes is converted to
          a stroke equidistant from its nearest outer boundaries.  If
          the object has holes it creates a ring midway between each
          hole and its near outer boundary.  This differ from shrink in
          that shrink converts objects without holes to a single pixels
          and thin to a stroke.  It preserves Euler number.

     'tophat'
          Performs a top hat operation, a opening operation (which is an
          erosion followed by a dilation) and finally substracts the
          original image (see 'imtophat').  BW can have any number of
          dimensions, and 'strel ("hypercube", ndims (BW), 3)' is used
          as structuring element.

     Some useful concepts to understant operators:

     Operations are defined on 3-by-3 blocks of data, where the pixel in
     the center of the block.  Those pixels are numerated as follows:

     X3   X2   X1
     X4   X    X0
     X5   X6   X7

     *Neighbourhood definitions used in operation descriptions:*
     ''four-connected''
          It refers to pixels which are connected horizontally or
          vertically to X: X1, X3, X5 and X7.
     ''eight-connected''
          It refers to all pixels which are connected to X: X0, X1, X2,
          X3, X4, X5, X6 and X7.

     *Compatibility notes:*
     ''skel''
          Algorithm used here is described in Pratt's book.  When
          applying it to the "circles" image in MATLAB documentation,
          results are not the same.  Perhaps MATLAB uses Blum's algoritm
          (for further info please read comments in code).
     ''skel-pratt''
          This option is not available in MATLAB.
     ''skel-lantuejoul''
          This option is not available in MATLAB.
     ''thicken''
          This implementation also thickens image borders.  This can
          easily be avoided i necessary.  MATLAB documentation doesn't
          state how it behaves.

     References: W. K. Pratt, "Digital Image Processing" Gonzalez and
     Woods, "Digital Image Processing"

     See also: imdilate, imerode, imtophat, imbothat, makelut, applylut.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Perform morphological operation on binary image.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 813
 -- Function File: bwperim (BW)
 -- Function File: bwperim (BW, CONN)
     Find perimeter of objects in binary images.

     Values from the matrix BW are considered part of an object
     perimeter if their value is non-zero and is connected to at least
     one zero-valued element.

     Element connectivity CONN, to define the size of objects, can be
     specified with a numeric scalar (number of elements in the
     neighborhood):

     '4 or 8'
          for 2 dimensional matrices;
     '6, 18 or 26'
          for 3 dimensional matrices;

     or with a binary matrix representing a connectivity array.
     Defaults to 'conndef (ndims (BW), "minimal")' which is equivalent
     to CONN of 4 and 6 for 2 and 3 dimensional matrices respectively.

     See also: bwarea, bwboundaries, imerode, mmgrad.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Find perimeter of objects in binary images.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 434
 -- Function File: [IMOUT, IDX] = bwselect( IM, COLS, ROWS, CONNECT)
     Select connected regions in a binary image.

     'IM'
          binary input image
     '[COLS, ROWS]'
          vectors of starting points (x,y)
     'CONNECT'
          connectedness 4 or 8.  default is 8
     'IMOUT'
          the image of all objects in image im that overlap pixels in
          (cols,rows)
     'IDX'
          index of pixels in imout




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Select connected regions in a binary image.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 440
 -- Function File: BOARD = checkerboard ()
 -- Function File: BOARD = checkerboard (SIDE)
 -- Function File: BOARD = checkerboard (SIDE, SIZE)
 -- Function File: BOARD = checkerboard (SIDE, M, N)
     Create checkerboard.

     Each tile of the checkerboard is made of four squares SIDE pixels
     wide.  The created checkerboard itself will be SIZE, or MxN tiles
     wide.  Defaults to 4x4 tiles 10 pixels wide.

     See also: repmat.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
Create checkerboard.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2377
 -- Function File: col2im (B, BLOCK_SIZE, A_SIZE)
 -- Function File: col2im (B, BLOCK_SIZE, A_SIZE, BLOCK_TYPE)
     Rearrange block columns back into matrix.

     Rearranges columns of the matrix B, representing blocks of size
     BLOCK_SIZE from a matrix of size A_SIZE, back into its original
     size (usually close to A_SIZE.  This function is most useful as
     reverse operation to 'im2col'.

     Blocks are assumed to be from one of two types as defined by
     BLOCK_TYPE (defaults to "sliding"):

     "distinct"
          Each column of B is assumed to be distinct blocks, with no
          overlapping elements, of size BLOCK_SIZE, to rebuild a matrix
          of size A_SIZE.  Any padding that may have been required to
          form B from a matrix of A_SIZE, is removed accordingly.

     "sliding"
          This reshapes B into a matrix of size 'A_SIZE - BLOCK_SIZE
          +1'.  Sliding blocks are most useful to apply a sliding window
          filter with functions that act along columns.  In this
          situation, B is usually a row vector, so that if BLOCK_SIZE is
          [1 1], A_SIZE will be the size of the output matrix.  When
          converting a matrix into blocks with 'im2col', there will be
          less blocks to account to borders, so if BLOCK_SIZE is the
          same in both 'col2im' and 'im2col', A_SIZE can be the size out
          the ouput from 'im2col'.

     Blocks are assumed to have been from a matrix, the same direction
     elements are organized in an Octave matrix (top to bottom, then
     left to right), and the direction that blocks are taken in
     'im2col'.

          ## Get distinct blocks of size [2 3] from A into columns, and
          ## put them back together into the original position
          A = reshape (1:24, [4 6])
          B = im2col (A, [2 3], "distinct")
          col2im (B, [2 3], [4 6], "distinct")

          ## Get sliding blocks of size [2 3] from A into columns, calculate
          ## the mean of each block (mean of each column), and reconstruct A.
          ## This is the equivalent to a sliding window filter and ignoring
          ## borders.
          A = reshape (1:24, [4 6])
          B = im2col (A, [2 3], "sliding")
          C = mean (B);
          col2im (C, [1 1], [3 4], "sliding")

     See also: blockproc, bestblk, colfilt, im2col, nlfilter, reshape.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Rearrange block columns back into matrix.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2971
 -- Function File: colfilt (A, BLOCK_SIZE, BLOCK_TYPE, FUNC)
 -- Function File: colfilt (A, BLOCK_SIZE, SUBSIZE, BLOCK_TYPE, FUNC,
          ...)
 -- Function File: colfilt (A, "indexed", ...)
 -- Function File: colfilt (..., FUNC, EXTRA_ARGS, ...)
     Apply function to matrix blocks

     Executes the function FUNC on blocks of size BLOCK_SIZE, taken from
     the matrix A.  Both the matrix A, and the block can have any number
     of dimensions.

     The different blocks are organized into a matrix, each block as a
     single column, and passed as the first to the function handle FUNC.
     Any input arguments to 'colfilt' after FUNC are passed to FUNC
     after the blocks matrix.

     Blocks can be of two different types as defined by the string
     BLOCK_TYPE:

     "distinct"
          Each block is completely distinct from the other, with no
          overlapping elements.  FUNC must return a matrix of exactly
          the same size as its input.

     "sliding"
          Each possible block of size BLOCK_SIZE inside A is used.  FUNC
          should act along the column dimension (be a column compression
          function) and return a vector of length equal to the number of
          columns of its input.

     The optional argument SUBSIZE divides A into smaller pieces before
     generating the matrices with one block per column in order to save
     memory.  It is currently only accepted for MATLAB compatibility.

     If A is an indexed image, the second argument should be the string
     "indexed" so that any required padding is done correctly.  The
     padding value will be 0 except for indexed images of class uint8
     and uint16.

     This function is mostly useful to apply moving or sliding window
     filter when BLOCK_TYPE is "sliding".  However, for many cases,
     specialized functions perform much faster.  For the following
     common cases, consider the suggested alternatives;

     moving average
          A moving average filter is equivalent to convolve with a
          matrix of '1/N' sized BLOCK_SIZE, where N is the total number
          of elements in a block.  Use 'convn (A, (1/N) * ones
          (BLOCK_SIZE) *, "same")'

     maximum or minimum
          This is the equivalent to a dilation and erosion.  Use
          'imdilate' or 'imerode'.

     any or all
          Same as dilation and erosion but with logical input.  Use
          'imdilate' or 'imerode' with 'logical (A)'.

     median
          Use 'medfilt2' if A is only 2 dimensional, and 'ordfiltn' with
          the 'floor (prod (N/ 2)' th element, where N is the total
          number of elements in a block (add 1 if it is an even number).

     sort or nth_element
          Use 'ordfiltn'.

     standard deviation
          Use 'stdfilt'.

     sum
          Use a matrix of 1 to perform convolution, 'convn (A, ones
          (BLOCK_SIZE), "same")'

     See also: bestblk, blockproc, col2im, im2col, nlfilter.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Apply function to matrix blocks



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
colorgradient


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 542
 -- Function File: M = colorgradient (C, W, N)
     Define a colour map which smoothly traverses the given colors.  C
     contains the colours, one row per r,g,b value.  W(i) is the
     relative length of the transition from colour i to colour i+1 in
     the entire gradient.  The default is ones(rows(C)-1,1).  n is the
     length of the colour map.  The default is rows(colormap).

     E.g.,
          colorgradient([0,0,1; 1,1,0; 1,0,0])  # blue -> yellow -> red
          x = linspace(0,1,200);
          imagesc(x(:,ones(30,1)))';




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Define a colour map which smoothly traverses the given colors.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 645
 -- Function File: conndef (NUM_DIMS, TYPE)
     Create connectivity array.

     Creates a binary matrix of NUM_DIMS dimensions for morphological
     operations, where elements with a value of 1 are considered
     connected to the center element (a connectivity array).

     There are two possible TYPEs of connectivity array, defined with
     the strings:
     "minimal"
          Neighbours touch the central element on a
          (NUM_DIMS-1)-dimensional surface.

     "maximal"
          Neighbours touch the central element in any way.  Equivalent
          to 'ones (repmat (3, 1, NUM_DIMS))'.

     See also: iptcheckconn, strel.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Create connectivity array.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
corr2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 204
 -- Function File: R = corr2 (I,J)
     Compute correlation coefficients of images.

     The two images I and J must be real type matrices or vectors of
     same size.

     See also: corr, cov, std2.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Compute correlation coefficients of images.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3508
 -- Function File: T = cp2tform (RW_PT, AP_PT, TRANSTYPE)
 -- Function File: T = cp2tform (RW_PT, AP_PT, TRANSTYPE, OPT)
     Returns a transformation structure T (see "help maketform" for the
     form of the structure) that can be further used to transform
     coordinates from one space (here denoted "RW" for "real world") to
     another (here denoted "AP" for "apparent").  The transform is
     infered from two n-by-2 arrays, RW_PT and AP_PT, wich contain the
     coordinates of n control points in the two 2D spaces.  Transform
     coefficients are stored in T.tdata.  Interpretation of transform
     coefficients depends on the requested transform type TRANSTYPE:

     "affine"
          Return both forward (RW->AP) and inverse (AP->RW) transform
          coefficients T.tdata.T and T.tdata.Tinv.  Transform
          coefficients are 3x2 matrices which can be used as follows:

               RW_PT = [AP_PT ones(rows (ap_pt,1))] * Tinv
               AP_PT = [RW_PT ones(rows (rw_pt,1))] * T
          This transformation is well suited when parallel lines in one
          space are still parallel in the other space (e.g.  shear,
          translation, ...).

     "nonreflective similarity"
          Same as "affine" except that the transform matrices T and Tinv
          have the form
               Tcoefs = [a -b;
                         b  a;
                         c  d]
          This transformation may represent rotation, scaling and
          translation.  Reflection is not included.

     "similarity"
          Same as "nonreflective similarity" except that the transform
          matrices T and Tinv may also have the form
               Tcoefs = [a  b;
                         b -a;
                         c  d]
          This transformation may represent reflection, rotation,
          scaling and translation.  Generates a warning if the
          nonreflective similarity is better suited.

     "projective"
          Return both forward (RW->AP) and inverse (AP->RW) transform
          coefficients T.tdata.T and T.tdata.Tinv.  Transform
          coefficients are 3x3 matrices which can be used as follows:

               [u v w] = [AP_PT ones(rows (ap_pt,1))] * Tinv
               RW_PT = [u./w, v./w];
               [x y z] = [RW_PT ones(rows (rw_pt,1))] * T
               AP_PT = [x./z y./z];
          This transformation is well suited when parallel lines in one
          space all converge toward a vanishing point in the other
          space.

     "polynomial"
          Here the OPT input argument is the order of the polynomial
          fit.  OPT must be 2, 3 or 4 and input control points number
          must be respectively at least 6, 10 and 15.  Only the inverse
          transform (AP->RW) is included in the structure T.  Denoting x
          and y the apparent coordinates vector and xrw, yrw the the
          real world coordinates.  Inverse transform coefficients are
          stored in a (6,10 or 15)x2 matrix which can be used as
          follows:

               Second order:
               [xrw yrw] = [1 x y x*y x^2 y^2] * Tinv
               Third order:
               [xrw yrw] = [1 x y x*y x^2 y^2 y*x^2 x*y^2 x^3 y^3] * Tinv
               Fourth order:
               [xrw yrw] = [1 x y x*y x^2 y^2 y*x^2 x*y^2 x^3 y^3 x^3*y x^2*y^2 x*y^3 x^4 y^4] * Tinv
          This transform is well suited when lines in one space become
          curves in the other space.

     See also: tformfwd, tforminv, maketform.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Returns a transformation structure T (see "help maketform" for the form
of the s



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
edge


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6174
 -- Function File: BW = edge (IM, METHOD)
 -- Function File: BW = edge (IM, METHOD, ARG1, ARG2)
 -- Function File: [BW, THRESH] = edge (...)
     Detect edges in the given image using various methods.  The first
     input IM is the gray scale image in which edges are to be detected.
     The second argument controls which method is used for detecting the
     edges.  The rest of the input arguments depend on the selected
     method.  The first output BW is a 'logical' image containing the
     edges.  Most methods also returns an automatically computed
     threshold as the second output.

     The METHOD input argument can any of the following strings (the
     default value is "Sobel")

     "Sobel"
          Finds the edges in IM using the Sobel approximation to the
          derivatives.  Edge points are defined as points where the
          length of the gradient exceeds a threshold and is larger than
          it's neighbours in either the horizontal or vertical
          direction.  The threshold is passed to the method in the third
          input argument ARG1.  If one is not given, a threshold is
          automatically computed as 4*M, where M is the mean of the
          gradient of the entire image.  The optional 4th input argument
          controls the direction in which the gradient is approximated.
          It can be either "horizontal", "vertical", or "both"
          (default).

     "Prewitt"
          Finds the edges in IM using the Prewitt approximation to the
          derivatives.  This method works just like "Sobel" except a
          different aproximation the gradient is used.

     "Roberts"
          Finds the edges in IM using the Roberts approximation to the
          derivatives.  Edge points are defined as points where the
          length of the gradient exceeds a threshold and is larger than
          it's neighbours in either the horizontal or vertical
          direction.  The threshold is passed to the method in the third
          input argument ARG1.  If one is not given, a threshold is
          automatically computed as 6*M, where M is the mean of the
          gradient of the entire image.  The optional 4th input argument
          can be either "thinning" (default) or "nothinning".  If it is
          "thinning" a simple thinning procedure is applied to the edge
          image such that the edges are only one pixel wide.  If ARG2 is
          "nothinning", this procedure is not applied.

     "Kirsch"
          Finds the edges in IM using the Kirsch approximation to the
          derivatives.  Edge points are defined as points where the
          length of the gradient exceeds a threshold and is larger than
          it's neighbours in either the horizontal or vertical
          direction.  The threshold is passed to the method in the third
          input argument ARG1.  If one is not given, a threshold is
          automatically computed as M, where M is the mean of the
          gradient of the entire image.  The optional 4th input argument
          controls the direction in which the gradient is approximated.
          It can be either "horizontal", "vertical", or "both"
          (default).

     "LoG"
          Finds edges in IM by convolving with the Laplacian of Gaussian
          (LoG) filter, and finding zero crossings.  Only zero crossings
          where the filter response is larger than an automatically
          computed threshold are retained.  The threshold is passed to
          the method in the third input argument ARG1.  If one is not
          given, a threshold is automatically computed as 0.75*M, where
          M is the mean of absolute value of LoG filter response.  The
          optional 4th input argument sets the spread of the LoG filter.
          By default this value is 2.

     "Zerocross"
          Finds edges in the image IM by convolving it with the
          user-supplied filter ARG2 and finding zero crossings larger
          than the threshold ARG1.  If ARG1 is [] a threshold is
          computed as the mean value of the absolute filter response.

     "Canny"
          Finds edges using the Canny edge detector.  The optional third
          input argument ARG1 sets the thresholds used in the hysteresis
          thresholding.  If ARG1 is a two dimensional vector it's first
          element is used as the lower threshold, while the second
          element is used as the high threshold.  If, on the other hand,
          ARG1 is a single scalar it is used as the high threshold,
          while the lower threshold is 0.4*ARG1.  The optional 4th input
          argument ARG2 is the spread of the low-pass Gaussian filter
          that is used to smooth the input image prior to estimating
          gradients.  By default this scale parameter is 2.

     "Lindeberg"
          Finds edges using in IM using the differential geometric
          single-scale edge detector given by Tony Lindeberg.  The
          optional third input argument ARG1 is the scale (spread of
          Gaussian filter) at which the edges are computed.  By default
          this 2.

     "Andy"
          A.Adler's idea (c) 1999.  Somewhat based on the canny method.
          The steps are
            1. Do a Sobel edge detection and to generate an image at a
               high and low threshold.
            2. Edge extend all edges in the LT image by several pixels,
               in the vertical, horizontal, and 45 degree directions.
               Combine these into edge extended (EE) image.
            3. Dilate the EE image by 1 step.
            4. Select all EE features that are connected to features in
               the HT image.

          The parameters for the method is given in a vector:
          params(1)==0 or 4 or 8
               Perform x connected dilatation (step 3).
          params(2)
               Dilatation coeficient (threshold) in step 3.
          params(3)
               Length of edge extention convolution (step 2).
          params(4)
               Coeficient of extention convolution in step 2.
          defaults = [8, 1, 3, 3]

     See also: fspecial, nonmax_supress.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Detect edges in the given image using various methods.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 584
 -- Function File: E = entropy (IM)
 -- Function File: E = entropy (IM, NBINS)
     Computes the entropy of an image.

     The entropy of the elements of the image IM is computed as

          E = -sum (P .* log2 (P)

     where P is the distribution of the elements of IM.  The
     distribution is approximated using a histogram with NBINS cells.
     If IM is 'logical' then two cells are used by default.  For other
     classes 256 cells are used by default.

     When the entropy is computed, zero-valued cells of the histogram
     are ignored.

     See also: entropyfilt.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
Computes the entropy of an image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
entropyfilt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1200
 -- Function File: E = entropyfilt (IM)
 -- Function File: E = entropyfilt (IM, DOMAIN)
 -- Function File: E = entropyfilt (IM, DOMAIN, PADDING, ...)
     Computes the local entropy in a neighbourhood around each pixel in
     an image.

     The entropy of the elements of the neighbourhood is computed as

          E = -sum (P .* log2 (P)

     where P is the distribution of the elements of IM.  The
     distribution is approximated using a histogram with NBINS cells.
     If IM is 'logical' then two cells are used.  For other classes 256
     cells are used.

     When the entropy is computed, zero-valued cells of the histogram
     are ignored.

     The neighbourhood is defined by the DOMAIN binary mask.  Elements
     of the mask with a non-zero value are considered part of the
     neighbourhood.  By default a 9 by 9 matrix containing only non-zero
     values is used.

     At the border of the image, extrapolation is used.  By default
     symmetric extrapolation is used, but any method supported by the
     'padarray' function can be used.  Since extrapolation is used, one
     can expect a lower entropy near the image border.

     See also: entropy, paddarray, stdfilt.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
Computes the local entropy in a neighbourhood around each pixel in an
image.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 779
 -- Function File: FCC = fchcode (BOUND)
     Determine the Freeman chain code for a boundary.

     'fchcode' computes the Freeman chain code for the N-connected
     boundary BOUND.  N must be either 8 or 4.

     BOUND is a K-by-2 matrix containing the row/column coordinates of
     points on the boundary.  Optionally, the first point can be
     repeated as the last point, resulting in a (K+1)-by-2 matrix.

     FCC is a structure containing the following elements.

           x0y0   = Row/column coordinates where the code starts (1-by-2)
           fcc    = Freeman chain code (1-by-K)
           diff   = First difference of fcc (1-by-K)

     The code uses the following directions.

           3 2 1
           4 . 0
           5 6 7

     See also: bwboundaries.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Determine the Freeman chain code for a boundary.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 374
 -- Function File: fftconv2 (A, B, SHAPE)
 -- Function File: fftconv2 (V1, V2, A, SHAPE)
     Convolve 2 dimensional signals using the FFT.

     This method is faster but less accurate than CONV2 for large A and
     B.  It also uses more memory.  A small complex component will be
     introduced even if both A and B are real.

     See also: conv2, fftconv, fft, ifft.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Convolve 2 dimensional signals using the FFT.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 597
 -- Function File: OUTBND = findbounds (T, INBND)
     Estimate bounds for spatial transformation.

     Given a transformation structure T (see e.g.  maketform) and bounds
     INBND (2-by-ndims_in) in an input space, returns an estimation of
     the bounds in the output space OUTBND (2-by-ndims_out).  For
     instance two dimensionnal bounds could be represented as : [xmin
     ymin; xmax ymax].  If T does not define a forward trasform (i.e.
     for 'polynomial'), the output bounds are infered using fsolve and
     the inverse transform.

     See also: maketform, cp2tform, tformfwd.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Estimate bounds for spatial transformation.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3283
 -- Function File: FILTER = fspecial( TYPE, ARG1, ARG2)
     Create spatial filters for image processing.

     TYPE determines the shape of the filter and can be
     "average"
          Rectangular averaging filter.  The optional argument ARG1
          controls the size of the filter.  If ARG1 is an integer N, a N
          by N filter is created.  If it is a two-vector with elements N
          and M, the resulting filter will be N by M.  By default a 3 by
          3 filter is created.
     "disk"
          Circular averaging filter.  The optional argument ARG1
          controls the radius of the filter.  If ARG1 is an integer N, a
          2 N + 1 filter is created.  By default a radius of 5 is used.
     "gaussian"
          Gaussian filter.  The optional argument ARG1 controls the size
          of the filter.  If ARG1 is an integer N, a N by N filter is
          created.  If it is a two-vector with elements N and M, the
          resulting filter will be N by M.  By default a 3 by 3 filter
          is created.  The optional argument ARG2 sets spread of the
          filter.  By default a spread of 0.5 is used.
     "log"
          Laplacian of Gaussian.  The optional argument ARG1 controls
          the size of the filter.  If ARG1 is an integer N, a N by N
          filter is created.  If it is a two-vector with elements N and
          M, the resulting filter will be N by M.  By default a 5 by 5
          filter is created.  The optional argument ARG2 sets spread of
          the filter.  By default a spread of 0.5 is used.
     "laplacian"
          3x3 approximation of the laplacian.  The filter is
          approximated as
               (4/(ALPHA+1))*[ALPHA/4,     (1-ALPHA)/4, ALPHA/4; ...
                              (1-ALPHA)/4, -1,          (1-ALPHA)/4;  ...
                              ALPHA/4,     (1-ALPHA)/4, ALPHA/4];
          where ALPHA is a number between 0 and 1.  This number can be
          controlled via the optional input argument ARG1.  By default
          it is 0.2.
     "unsharp"
          Sharpening filter.  The following filter is returned
               (1/(ALPHA+1))*[-ALPHA,   ALPHA-1, -ALPHA; ...
                               ALPHA-1, ALPHA+5,  ALPHA-1; ...
                              -ALPHA,   ALPHA-1, -ALPHA];
          where ALPHA is a number between 0 and 1.  This number can be
          controlled via the optional input argument ARG1.  By default
          it is 0.2.
     "motion"
          Moion blur filter of width 1 pixel.  The optional input
          argument ARG1 controls the length of the filter, which by
          default is 9.  The argument ARG2 controls the angle of the
          filter, which by default is 0 degrees.
     "sobel"
          Horizontal Sobel edge filter.  The following filter is
          returned
               [ 1,  2,  1;
                 0,  0,  0;
                -1, -2, -1 ]
     "prewitt"
          Horizontal Prewitt edge filter.  The following filter is
          returned
               [ 1,  1,  1;
                 0,  0,  0;
                -1, -1, -1 ]
     "kirsch"
          Horizontal Kirsch edge filter.  The following filter is
          returned
               [ 3,  3,  3;
                 3,  0,  3;
                -5, -5, -5 ]




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Create spatial filters for image processing.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
getrangefromclass


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 927
 -- Function File: RANGE = getrangefromclass (IMG)
     Return display range of image.

     For a given image IMG, returns the 1x2 element matrix RANGE with
     the display range (minimum and maximum display values) for an image
     of that class.

     Images of different classes have different display ranges, the
     ranges of values that Octave will interpret between black to white.
     For an integer image, the range is from 'intmin' to 'intmax' of
     that class; for images of class logical, single, or double, the
     range is [0 1].

     Note that RANGE will be of class double, independently of the class
     of IMG.

          getrangefromclass (ones (5)) # note that class is 'double'
               => [0   1]
          getrangefromclass (logical (ones (5)))
               => [0   1]
          getrangefromclass (int8 (ones (5)))
               => [-128  127]

     See also: intmin, intmax, bitmax.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Return display range of image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
grayslice


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 514
 -- Function File: X = grayslice (I,N)
 -- Function File: X = grayslice (I,V)
     Creates an indexed image X from an intensitiy image I using
     multiple threshold levels.  A scalar integer value N sets the
     levels to

          1  2       n-1
          -, -, ..., ---
          n  n        n

     X = grayslice(I,5);

     For irregular threshold values a real vector V can be used.  The
     values must be in the range [0,1].

     X = grayslice(I,[0.1,0.33,0.75,0.9])

     See also: im2bw, gray2ind.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Creates an indexed image X from an intensitiy image I using multiple
threshold l



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5386
 -- Function File: [LEVEL, SEP] = graythresh (IMG)
 -- Function File: [LEVEL, SEP] = graythresh (IMG, METHOD, OPTIONS)
 -- Function File: [LEVEL, SEP] = graythresh (HIST, ...)
     Compute global image threshold.

     Given an image IMG finds the optimal threshold value LEVEL for
     conversion to a binary image with 'im2bw'.  Color images are
     converted to grayscale before LEVEL is computed.  An image
     histogram HIST can also be used to allow for preprocessing of the
     histogram.

     The optional argument METHOD is the algorithm to be used (default's
     to Otsu).  Some methods may have other OPTIONS and/or return an
     extra value SEP (see each entry for details).  The available
     METHODs are:

     Otsu (default)
          Implements Otsu's method as described in 'Nobuyuki Otsu
          (1979). "A threshold selection method from gray-level
          histograms", IEEE Trans. Sys., Man., Cyber. 9 (1): 62-66'.
          This algorithm chooses the threshold to minimize the
          intraclass variance of the black and white pixels.

          The second output, SEP represents the "goodness" (or
          separability) of the threshold at LEVEL.  It is a value within
          the range [0 1], the lower bound (zero) being attainable by,
          and only by, histograms having a single constant gray level,
          and the upper bound being attainable by, and only by,
          two-valued pictures.

     concavity
          Find a global threshold for a grayscale image by choosing the
          threshold to be in the shoulder of the histogram 'A.
          Rosenfeld, and P. De La Torre (1983). "Histogram concavity
          analysis as an aid in threshold selection", IEEE Transactions
          on Systems, Man, and Cybernetics, 13: 231-235'.

     intermodes
          This assumes a bimodal histogram and chooses the threshold to
          be the mean of the two peaks of the bimodal histogram 'J. M.
          S. Prewitt, and M. L. Mendelsohn (1966). "The analysis of cell
          images", Annals of the New York Academy of Sciences, 128:
          1035-1053'.

          Images with histograms having extremely unequal peaks or a
          broad and flat valley are unsuitable for this method.

     intermeans
          Iterative procedure based on the iterative intermeans
          algorithm of 'T. Ridler, and S. Calvard (1978). "Picture
          thresholding using an iterative selection method", IEEE
          Transactions on Systems, Man, and Cybernetics, 8: 630-632' and
          'H. J. Trussell (1979). "Comments on 'Picture thresholding
          using an iterative selection method'", IEEE Transactions on
          Systems, Man, and Cybernetics, 9: 311'.

          Note that several implementations of this method exist.  See
          the source code for details.

     MaxEntropy
          Implements Kapur-Sahoo-Wong (Maximum Entropy) thresholding
          method based on the entropy of the image histogram 'J. N.
          Kapur, P. K. Sahoo, and A. C. K. Wong (1985). "A new method
          for gray-level picture thresholding using the entropy of the
          histogram", Graphical Models and Image Processing, 29(3):
          273-285'.

     MaxLikelihood
          Find a global threshold for a grayscale image using the
          maximum likelihood via expectation maximization method 'A. P.
          Dempster, N. M. Laird, and D. B. Rubin (1977). "Maximum
          likelihood from incomplete data via the EM algorithm", Journal
          of the Royal Statistical Society, Series B, 39:1-38'.

     mean
          The mean intensity value.  It is mostly used by other methods
          as a first guess threshold.

     MinError
          An iterative implementation of Kittler and Illingworth's
          Minimum Error thresholding 'J. Kittler, and J. Illingworth
          (1986). "Minimum error thresholding", Pattern recognition, 19:
          41-47'.

          This implementation seems to converge more often than the
          original.  Nevertheless, sometimes the algorithm does not
          converge to a solution.  In that case a warning is displayed
          and defaults to the initial estimate of the mean method.

     minimum
          This assumes a bimodal histogram and chooses the threshold to
          be in the valley of the bimodal histogram.  This method is
          also known as the mode method 'J. M. S. Prewitt, and M. L.
          Mendelsohn (1966). "The analysis of cell images", Annals of
          the New York Academy of Sciences, 128: 1035-1053'.

          Images with histograms having extremely unequal peaks or a
          broad and flat valley are unsuitable for this method.

     moments
          Find a global threshold for a grayscale image using moment
          preserving thresholding method 'W. Tsai (1985).
          "Moment-preserving thresholding: a new approach", Computer
          Vision, Graphics, and Image Processing, 29: 377-393'

     percentile
          Assumes a specific fraction of pixels (set at OPTIONS) to be
          background.  If no value is given, assumes 0.5 (equal
          distribution of background and foreground) 'W Doyle (1962).
          "Operation useful for similarity-invariant pattern
          recognition", Journal of the Association for Computing
          Machinery 9: 259-267'

     See also: im2bw.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Compute global image threshold.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 463
 -- Function File: J = histeq (I, N)
     Equalize histogram of grayscale image.

     The histogram contains N bins, which defaults to 64.

     I: Image in double format, with values from 0.0 to 1.0.

     J: Returned image, in double format as well.

     Note that the algorithm used for histogram equalization gives
     results qualitatively comparable but numerically different from
     MATLAB implementation.

     See also: imhist, mat2gray, brighten.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Equalize histogram of grayscale image.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 777
 -- Function File: ACCUM = hough_circle (BW, R)
     Perform the Hough transform for circles with radius R on the
     black-and-white image BW.

     As an example, the following shows how to compute the Hough
     transform for circles with radius 3 or 7 in the image IM
          bw = edge(im);
          accum = hough_circle(bw, [3, 7]);
     If IM is an NxM image ACCUM will be an NxMx2 array, where
     ACCUM(:,:,1) will contain the Hough transform for circles with
     radius 3, and ACCUM(:,:,2) for radius 7.  To find good circles you
     now need to find local maximas in ACCUM, which can be a hard
     problem.  If you find a local maxima in ACCUM(row, col, 1) it means
     that a good circle exists with center (row,col) and radius 3.

     See also: houghtf.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Perform the Hough transform for circles with radius R on the
black-and-white ima



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2212
 -- Function File: H = houghtf (BW)
 -- Function File: H = houghtf (BW, METHOD)
 -- Function File: H = houghtf (BW, METHOD, ARG)
     Perform the Hough transform for lines or circles.

     The METHOD argument chooses between the Hough transform for lines
     and circles.  It can be either "line" (default) or "circle".

     *Line Detection*

     If METHOD is "line", the function will compute the Hough transform
     for lines.  A line is parametrised in R and THETA as
          R = x*cos(THETA) + y*sin(THETA),
     where R is distance between the line and the origin, while THETA is
     the angle of the vector from the origin to this closest point.  The
     result H is an N by M matrix containing the Hough transform.  Here,
     N is the number different values of R that has been attempted.
     This is computed as '2*diag_length - 1', where 'diag_length' is the
     length of the diagonal of the input image.  M is the number of
     different values of THETA.  These can be set through the third
     input argument ARG.  This must be a vector of real numbers, and is
     by default 'pi*(-90:90)/180'.

     *Circle Detection*

     If METHOD is "circle" the function will compute the Hough transform
     for circles.  The circles are parametrised in R which denotes the
     radius of the circle.  The third input argument ARG must be a real
     vector containing the possible values of R.  If the input image is
     N by M, then the result H will be an N by M by K array, where K
     denotes the number of different values of R.

     As an example, the following shows how to compute the Hough
     transform for circles with radius 3 or 7 in the image IM
          bw = edge(im);
          H = houghtf(bw, "circle", [3, 7]);
     Here H will be an NxMx2 array, where H(:,:,1) will contain the
     Hough transform for circles with radius 3, and H(:,:,2) for radius
     7.  To find good circles you now need to find local maximas in H.
     If you find a local maxima in H(row, col, 1) it means that a good
     circle exists with center (row,col) and radius 3.  One way to
     locate maximas is to use the 'immaximas' function.

     See also: hough_line, hough_circle, immaximas.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Perform the Hough transform for lines or circles.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
im2bw


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 752
 -- Function File: im2bw (IMG, threshold)
 -- Function File: im2bw (X, CMAP, threshold)
     Convert image to binary, black and white, by threshold.

     The input image IMG can either be a grayscale or RGB image.  In the
     later case, IMG is first converted to grayscale with 'rgb2gray'.
     Input can also be an indexed image X in which case the colormap
     CMAP needs to be specified.

     The value of THRESHOLD should be in the range [0,1] independently
     of the class of IMG.  Values from other classes can be converted to
     the correct value with 'im2double' for example.  For an automatic
     threshold, consider using 'graythresh'.

          bw = im2bw (img, graythresh (img));

     See also: graythresh, ind2gray, rgb2gray.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Convert image to binary, black and white, by threshold.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2263
 -- Function File: im2col (A, BLOCK_SIZE)
 -- Function File: im2col (A, BLOCK_SIZE, BLOCK_TYPE)
 -- Function File: im2col (A, "indexed", ...)
     Rearrange blocks from matrix into columns.

     Rearranges blocks of size BLOCK_SIZE, sampled from the matrix A,
     into a serie of columns.  This effectively transforms any image
     into a 2 dimensional matrix, a block per column, which can then be
     passed to other functions that perform calculations along columns.

     Both blocks and matrix A can have any number of dimensions (though
     for sliding blocks, a block can't be larger than A in any
     dimension).  Blocks are always accessed in column-major order (like
     Octave arrays are stored) so that a matrix can be easily
     reconstructed with 'reshape' and 'col2im'.  For a 2 dimensional
     matrix, blocks are taken first from the top to the bottom, and then
     from the left to the right of the matrix.

     The sampling can be performed in two different ways as defined by
     BLOCK_TYPE (defaults to "sliding"):

     "distinct"
          Each block is completely distinct from the other, with no
          overlapping elements.  The matrix A is padded as required with
          a value of 0 (or 1 for non-integer indexed images).

     "sliding"
          A single block slides across A without any padding.

          While this can be used to perform sliding window operations
          such as maximum and median filters, specialized functions such
          as 'imdilate' and 'medfilt2' will be more efficient.

          Note that large images being arranged in large blocks can
          easily exceed the maximum matrix size (see 'sizemax').  For
          example, a matrix A of size 500x500, with sliding block of
          size [100 100], would require a matrix with 2.4108e+09
          elements, i.e., the number of elements in a block, '100*100',
          times the number of blocks, '(500-10+1) * (500-10+1)'.

     If A is an indexed image, the second argument should be the string
     "indexed" so that any required padding is done correctly.  The
     padding value will be 0 except for indexed images of class uint8
     and uint16.

     See also: blockproc, bestblk, col2im, colfilt, nlfilter, reshape.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Rearrange blocks from matrix into columns.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
im2double


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 822
 -- Function File: IM2 = im2double (IM1)
 -- Function File: IM2 = im2double (IM1, "indexed")
     Convert input image IM1 to double precision.

     The following images type are supported: double, single, uint8,
     uint16, int16, binary (logical), indexed.  If IM1 is an indexed
     images, the second argument must be a string with the value
     'indexed'.

     Processing will depend on the class of the input image IM1:
        * uint8, uint16, int16 - output will be rescaled for the
          interval [0 1] with the limits of the class;
        * double - output will be the same as input;
        * single - output will have the same values as input but the
          class will double;
        * indexed, logical - converted to double class.

     See also: im2bw, im2int16, im2single, im2uint8, im2uint16.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Convert input image IM1 to double precision.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 506
 -- Function File: IM2 = im2int16 (IM1)
     Convert input image IM1 to int16 precision.

     The following images type are supported: double, single, uint8,
     uint16, int16, binary (logical).

     Processing will depend on the class of the input image IM1:
        * int16 - returns the same as input
        * uint8, double, single, uint16, logical - output will be
          rescaled for the interval of the uint16 class [0 65535]

     See also: im2bw, im2double, im2single, im2uint8, im2uint16.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Convert input image IM1 to int16 precision.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
im2single


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 822
 -- Function File: IM2 = im2single (IM1)
 -- Function File: IM2 = im2single (IM1, "indexed")
     Convert input image IM1 to single precision.

     The following images type are supported: double, single, uint8,
     uint16, int16, binary (logical), indexed.  If IM1 is an indexed
     images, the second argument must be a string with the value
     'indexed'.

     Processing will depend on the class of the input image IM1:
        * uint8, uint16, int16 - output will be rescaled for the
          interval [0 1] with the limits of the class;
        * single - output will be the same as input;
        * double - output will have the same values as input but the
          class will single;
        * indexed, logical - converted to single class.

     See also: im2bw, im2double, im2int16, im2uint8, im2uint16.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Convert input image IM1 to single precision.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
im2uint16


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 800
 -- Function File: IM2 = im2uint16 (IM1)
 -- Function File: IM2 = im2uint16 (IM1, "indexed")
     Convert input image IM1 to uint16 precision.

     The following images type are supported: double, single, uint8,
     uint16, int16, binary (logical), indexed.  If IM1 is an indexed
     images, the second argument must be a string with the value
     'indexed'.

     Processing will depend on the class of the input image IM1:
        * uint16 - returns the same as input
        * uint8, double, single, int16, logical - output will be
          rescaled for the interval of the uint16 class [0 65535]
        * indexed - depends on the input class.  If double, no value can
          be above the max of the uint16 class (65535).

     See also: im2bw, im2double, im2int16, im2single, im2uint8.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Convert input image IM1 to uint16 precision.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 782
 -- Function File: IM2 = im2uint8 (IM1)
 -- Function File: IM2 = im2uint8 (IM1, "indexed")
     Convert input image IM1 to uint16 precision.

     The following images type are supported: double, single, uint8,
     uint16, int16, binary (logical), indexed.  If IM1 is an indexed
     images, the second argument must be a string with the value
     'indexed'.

     Processing will depend on the class of the input image IM1:
        * uint8 - returns the same as input
        * uint16, double, single, int16, logical - output will be
          rescaled for the interval of the uint8 class [0 255]
        * indexed - depends on the input class.  No value can be above
          the max of the uint8 class (255).

     See also: im2bw, im2double, im2int16, im2single, im2uint16.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Convert input image IM1 to uint16 precision.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
imabsdiff


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 789
 -- Function File: OUT = imabsdiff (A, B)
 -- Function File: OUT = imabsdiff (A, B, CLASS)
     Return absolute difference of image or constant to an image.

     If A and B are two images of same size and class, returns the
     absolute difference between B and A.

     The class of OUT will be the same as A unless A is logical in which
     case OUT will be double.  Alternatively, the class can be specified
     with CLASS.

     _Note 1_: you can force output class to be logical by specifying
     CLASS.  This is incompatible with MATLAB which will _not_ honour
     request to return a logical matrix.

     _Note 2_: the values are truncated to the mininum value of the
     output class.

     See also: imadd, imcomplement, imdivide, imlincomb, immultiply,
     imsubtract.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Return absolute difference of image or constant to an image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
imadd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 814
 -- Function File: OUT = imadd (A, B)
 -- Function File: OUT = imadd (A, B, CLASS)
     Add image or constant to an image.

     If A and B are two images of same size and class, the images are
     added.  Alternatively, if B is a floating-point scalar, its value
     is added to the image A.

     The class of OUT will be the same as A unless A is logical in which
     case OUT will be double.  Alternatively, it can be specified with
     CLASS.

     _Note 1_: you can force output class to be logical by specifying
     CLASS.  This is incompatible with MATLAB which will _not_ honour
     request to return a logical matrix.

     _Note 2_: the values are truncated to the maximum value of the
     output class.

     See also: imabsdiff, imcomplement, imdivide, imlincomb, immultiply,
     imsubtract.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Add image or constant to an image.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3599
 -- Function File: J = imadjust (I)
 -- Function File: J = imadjust (I,[LOW_IN;HIGH_IN])
 -- Function File: J = imadjust (I,[LOW_IN;HIGH_IN],[LOW_OUT;HIGH_OUT])
 -- Function File: J = imadjust (..., GAMMA)
 -- Function File: NEWMAP = imadjust (MAP, ...)
 -- Function File: RGB_OUT = imadjust (RGB, ...)
     Adjust image or colormap values to a specified range.

     'J=imadjust(I)' adjusts intensity image I values so that 1% of data
     on lower and higher values (2% in total) of the image is saturated;
     choosing for that the corresponding lower and higher bounds (using
     'stretchlim') and mapping them to 0 and 1.  J is an image of the
     same size as I which contains mapped values.  This is equivalent to
     'imadjust(I,stretchlim(I))'.

     'J=imadjust(I,[low_in;high_in])' behaves as described but uses
     LOW_IN and HIGH_IN values instead of calculating them.  It maps
     those values to 0 and 1; saturates values lower than first limit to
     0 and values higher than second to 1; and finally maps all values
     between limits linearly to a value between 0 and 1.  If '[]' is
     passes as '[low_in;high_in]' value, then '[0;1]' is taken as a
     default value.

     'J=imadjust(I,[low_in;high_in],[low_out;high_out])' behaves as
     described but maps output values between LOW_OUT and HIGH_OUT
     instead of 0 and 1.  A default value '[]' can also be used for this
     parameter, which is taken as '[0;1]'.

     'J=imadjust(...,gamma)' takes, in addition of 3 parameters
     explained above, an extra parameter GAMMA, which specifies the
     shape of the mapping curve between input elements and output
     elements, which is linear (as taken if this parameter is omitted).
     If GAMMA is above 1, then function is weighted towards lower
     values, and if below 1, towards higher values.

     'newmap=imadjust(map,...)' applies a transformation to a colormap
     MAP, which output is NEWMAP.  This transformation is the same as
     explained above, just using a map instead of an image.  LOW_IN,
     HIGH_IN, LOW_OUT, HIGH_OUT and GAMMA can be scalars, in which case
     the same values are applied for all three color components of a
     map; or it can be 1-by-3 vectors, to define unique mappings for
     each component.

     'RGB_out=imadjust(RGB,...)' adjust RGB image RGB (a M-by-N-by-3
     array) the same way as specified in images and colormaps.  Here too
     LOW_IN, HIGH_IN, LOW_OUT, HIGH_OUT and GAMMA can be scalars or
     1-by-3 matrices, to specify the same mapping for all planes, or
     unique mappings for each.

     The formula used to realize the mapping (if we omit saturation) is:

     'J = low_out + (high_out - low_out) .* ((I - low_in) / (high_in -
     low_in)) .^ gamma;'

     *Compatibility notes:*

        * Prior versions of imadjust allowed '[low_in; high_in]' and
          '[low_out; high_out]' to be row vectors.  Compatibility with
          this behaviour has been keeped, although preferred form is
          vertical vector (since it extends nicely to 2-by-3 matrices
          for RGB images and colormaps).
        * Previous version of imadjust, if 'low_in>high_in' it "negated"
          output.  Now it is negated if 'low_out>high_out', for
          compatibility with MATLAB.
        * Class of I is not considered, so limit values are not modified
          depending on class of the image, just treated "as is".  When
          Octave 2.1.58 is out, limits will be multiplied by 255 for
          uint8 images and by 65535 for uint16 as in MATLAB.

     See also: stretchlim, brighten.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Adjust image or colormap values to a specified range.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 604
 -- Function File: imbothat (IMG, SE)
     Perform morphological bottom hat filtering.

     The matrix IMG must be numeric while SE can be a:
        * strel object;
        * array of strel objects as returned by '@strel/getsequence';
        * matrix of 0's and 1's.

     A bottom hat transform corresponds to the difference between the
     closing of IMG and IMG itself, i.e., it is equivalent to:
          imclose (img, se) - img;

     A bottom-hat transform is also known as 'black', or 'closing',
     top-hat transform.

     See also: imerode, imdilate, imopen, imclose, imtophat, mmgradm.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Perform morphological bottom hat filtering.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 470
 -- Function File: imclose (IMG, SE)
     Perform morphological closing.

     The matrix IMG must be numeric while SE can be a:
        * strel object;
        * array of strel objects as returned by '@strel/getsequence';
        * matrix of 0's and 1's.

     The closing corresponds to a dilation followed by an erosion of
     IMG, using the same SE, i.e., it is equivalent to:
          imerode (imdilate (img, se), se);

     See also: imdilate, imerode, imopen.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 805
 -- Function File: imcomplement (A)
     Compute image complement or negative.

     Intuitively this corresponds to the intensity of bright and dark
     regions being reversed.  The exact operation performed is dependent
     on the class of the image.

     floating point
          Since floating point images are meant to have values in the
          range [0 1], this is equivalent 'A -1'.  This leads to values
          within the range to be inverted while others to equally
          distance from the limits.

     logical
          Equivalent to '! A'

     integer
          Inverts the values within the range of the data.  This is a
          different depending whether it's signed or unsigned integers
          class.

     See also: imadd, imdivide, imlincomb, immultiply, imsubtract.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Compute image complement or negative.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2244
 -- Function File: imcrop ()
 -- Function File: imcrop (IMG)
 -- Function File: imcrop (IND, CMAP)
 -- Function File: imcrop (H)
 -- Function File: imcrop (..., RECT)
 -- Function File: [CROPPED] = imcrop (...)
 -- Function File: [CROPPED, RECT] = imcrop (...)
 -- Function File: [X, Y, CROPPED, RECT] = imcrop (...)
     Crop image.

     Displays the image IMG in a figure window and waits for the user to
     select two points defining a bounding box.  First click on the top
     left and then on the bottom right corner of the region.  For an
     indexed image, a corresponding colormap can be specified in CMAP.
     For multi-dimensional images (each 2D image is concatenated in the
     4th dimension), only the first image is displayed.

     if no image data is given, uses the current figure or figure from
     graphics handle H.

     Non-interactive usage is supported if the last input argument is 4
     element vector RECT defining the region of interest.  The first two
     elements specify the initial X_INI and Y_INI coordinates, and the
     last two the WIDTH and HEIGHT, i.e., 'RECT = [X_INI Y_INI WIDTH
     HEIGHT]'.  Note how this the opposite of the majority of Octave
     indexing rules where rows come before columns.

     Returns the CROPPED image and a vector RECT with the coordinates
     and size for CROPPED.  If more than 3 output arguments are
     requested, also returns the X and Y data that define the coordinate
     system.

     _Note_: the values in RECT are not necessarily integer values and
     can't always be used directly as index values for other images.  To
     crop the same region from a multiple images of the same size,
     either using a multi-dimensional image:

          nd_img = cat (4, img1, img2, img3, img4);
          croped = imcrop (nd_img);
          cropped_1 = cropped(:,:,:,1);
          cropped_2 = cropped(:,:,:,2);
          cropped_3 = cropped(:,:,:,3);
          cropped_4 = cropped(:,:,:,4);

     or multiple calls to 'imcrop':

          [croped_1, rect] = imcrop (img1);
          cropped_2        = imcrop (img2, rect);
          cropped_3        = imcrop (img3, rect);
          cropped_4        = imcrop (img4, rect);

     See also: impixel, imshow.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
Crop image.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1023
 -- Function File: [Y, NEWMAP] = imdither (IMG)
 -- Function File: [Y, NEWMAP] = imdither (IMG, COLORS)
 -- Function File: [Y, NEWMAP] = imdither (IMG, COLORS, DITHTYPE)
 -- Function File: [Y, NEWMAP] = imdither (IMG, MAP)
 -- Function File: [Y, NEWMAP] = imdither (IMG, MAP, COLORS)
 -- Function File: [Y, NEWMAP] = imdither( IMG, MAP, COLORS, DITHTYPE)
     Reduce the number a colors of rgb or indexed image.

     Note: this requires the ImageMagick "convert" utility.  get this
     from www.imagemagick.org if required additional documentation of
     options is available from the convert man page.

     where DITHTYPE is a value from list:

        * "None"
        * "FloydSteinberg" (default)
        * "Riemersma"

     COLORS is a maximum number of colors in result map

     TODO: Add facility to use already created colormap over "-remap"
     option

     BUGS: This function return a 0-based indexed images when colormap
     size is lower or equals to 256 like at cmunique code

     See also: cmunique.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Reduce the number a colors of rgb or indexed image.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 623
 -- Function File: OUT = imdivide (A, B)
 -- Function File: OUT = imdivide (A, B, CLASS)
     Divide image by another image or constant.

     If A and B are two images of same size and class, A is divided by
     B.  Alternatively, if B is a floating-point scalar, A is divided by
     it.

     The class of OUT will be the same as A unless A is logical in which
     case OUT will be double.  Alternatively, it can be specified with
     CLASS.

     _Note_: the values are truncated to the mininum value of the output
     class.

     See also: imabsdiff, imadd, imcomplement, immultiply, imlincomb,
     imsubtract.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Divide image by another image or constant.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1465
 -- Function File: J = imfilter(I, F)
 -- Function File: J = imfilter(I, F, OPTIONS, ...)
     Computes the linear filtering of the image I and the filter F.  The
     computation is performed using double precision floating point
     numbers, but the class of the input image is preserved as the
     following example shows.
          I = 255*ones(100, 100, "uint8");
          f = fspecial("average", 3);
          J = imfilter(I, f);
          class(J)
          => ans = uint8

     The function also accepts a number of optional arguments that
     control the details of the filtering.  The following options is
     currently accepted
     'S'
          If a scalar input argument is given, the image is padded with
          this scalar as part of the filtering.  The default value is 0.
     '"symmetric"'
          The image is padded symmetrically.
     '"replicate"'
          The image is padded using the border of the image.
     '"circular"'
          The image is padded by circular repeating of the image
          elements.
     '"same"'
          The size of the output image is the same as the input image.
          This is the default behaviour.
     '"full"'
          Returns the full filtering result.
     '"corr"'
          The filtering is performed using correlation.  This is the
          default behaviour.
     '"conv"'
          The filtering is performed using convolution.

     See also: conv2, filter2, fspecial, padarray.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Computes the linear filtering of the image I and the filter F.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 897
 -- Function File: [GRADMAG, GRADDIR] = imgradient (IMG)
 -- Function File: [GRADMAG, GRADDIR] = imgradient (IMG, METHOD)
 -- Function File: [GRADMAG, GRADDIR] = imgradient (GX, GY)
     Compute the gradient magnitude and direction in degrees for an
     image.

     These are computed from the GX and XY gradients using
     'imgradientxy'.  The first input IMG is a gray scale image to
     compute the edges on.  The second input METHOD controls the method
     used to calculate the gradients.  Alternatively the first input GX
     can be the x gradient and the second input GY can be the y
     gradient.

     The first output GRADMAG returns the magnitude of the gradient.
     The second output GRADDIR returns the direction in degrees.

     The METHOD input argument must be a string specifying one of the
     methods supported by 'imgradientxy'.

     See also: edge, imgradientxy.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
Compute the gradient magnitude and direction in degrees for an image.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1249
 -- Function File: [GRADX, GRADY] = imgradientxy (IMG)
 -- Function File: [GRADX, GRADY] = imgradientxy (IMG, METHOD)
     Compute the x and y gradients of an image using various methods.

     The first input IMG is the gray scale image to compute the edges
     on.  The second input METHOD controls the method used to calculate
     the gradients.

     The first output GRADX returns the gradient in the x direction.
     The second output GRADY returns the gradient in the y direction.

     The METHOD input argument can be any of the following strings:

     "sobel" (default)
          Calculates the gradient using the Sobel approximation to the
          derivatives.

     "prewitt"
          Calculates the gradient using the Prewitt approximation to the
          derivatives.  This method works just like Sobel except a
          different approximation of the gradient is used.

     "central difference"
          Calculates the gradient using the central difference
          approximation to the derivatives: '(x(i-1) - x(i+1))/2'.

     "intermediate difference"
          Calculates the gradient in using the intermediate difference
          approximation to the derivatives: 'x(i) - x(i+1)'.

     See also: edge, imgradient.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Compute the x and y gradients of an image using various methods.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 825
 -- Function File: imhist (I)
 -- Function File: imhist (I, N)
 -- Function File: imhist (X, CMAP)
 -- Function File: [COUNTS, X] = imhist (...)
     Produce histogram counts of image I.

     The second argument can either be N, a scalar that specifies the
     number of bins; or CMAP, a colormap in which case X is expected to
     be an indexed image.  If not specified, N defauls to 2 for binary
     images, and 256 for grayscale images.

     If output is requested, COUNTS is the number of counts for each bin
     and X is a range for the bins so that 'stem (X, COUNTS)' will show
     the histogram.

     _Note:_ specially high peaks that may prevent an overview of the
     histogram may not be displayed.  To avoid this, use 'axis "auto y"'
     after the call to 'imhist'.

     See also: hist, histc, histeq.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Produce histogram counts of image I.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
imlincomb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 917
 -- Function File: OUT = imlincomb (FAC, IMG)
 -- Function File: OUT = imlincomb (FAC1, IMG1, FAC2, IMG2, ...)
 -- Function File: OUT = imlincomb (..., CLASS)
     Combine images linearly.

     Returns the computed image as per:

     OUT = FAC1*IMG1 + FAC2*IMG2 + ... + FACn*IMGn

     The images IMG1..n must all be of same size and class.  The factors
     FAC1..n must all be floating-point scalars.

     The class of OUT will be the same as IMGs unless IMGs are logical
     in which case OUT will be double.  Alternatively, it can be
     specified with CLASS.

     If applying several arithmetic operations on images, 'imlincomb' is
     more precise since calculations are performed at double precision.

     _Note 1_: you can force output class to be logical by specifying
     CLASS though it possibly doesn't make a lot of sense.

     See also: imadd, imcomplement, imdivide, immultiply, imsubtract.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
Combine images linearly.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
immaximas


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1107
 -- Function File: [R, C] = immaximas (IM, RADIUS)
 -- Function File: [R, C] = immaximas (IM, RADIUS, THRESH)
 -- Function File: [R, C, ...] = immaximas (...)
 -- Function File: [..., VAL] = immaximas (...)
     Finds local spatial maximas of the given image.  A local spatial
     maxima is defined as an image point with a value that is larger
     than all neighbouring values in a square region of width
     2*RADIUS+1.  By default RADIUS is 1, such that a 3 by 3
     neighbourhood is searched.  If the THRESH input argument is
     supplied, only local maximas with a value greater than THRESH are
     retained.

     The output vectors R and C contain the row-column coordinates of
     the local maximas.  The actual values are computed to sub-pixel
     precision by fitting a parabola to the data around the pixel.  If
     IM is N-dimensional, then N vectors will be returned.

     If IM is N-dimensional, and N+1 outputs are requested, then the
     last output will contain the image values at the maximas.
     Currently this value is not interpolated.

     See also: ordfilt2, ordfiltn.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Finds local spatial maximas of the given image.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 637
 -- Function File: OUT = immultiply (A, B)
 -- Function File: OUT = immultiply (A, B, CLASS)
     Multiply image by another image or constant.

     If A and B are two images of same size and class, the images are
     multiplied.  Alternatively, if B is a floating-point scalar, A is
     multiplie by it.

     The class of OUT will be the same as A unless A is logical in which
     case OUT will be double.  Alternatively, it can be specified with
     CLASS.

     _Note_: the values are truncated to the mininum value of the output
     class.

     See also: imabsdiff, imadd, imcomplement, imdivide, imlincomb,
     imsubtract.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Multiply image by another image or constant.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 753
 -- Function File: imnoise (A, TYPE)
 -- Function File: imnoise (..., OPTIONS)
     Add noise to image.

 -- Function File: imnoise (A, "gaussian", MEAN, VARIANCE)
     Additive gaussian noise with MEAN and VARIANCE defaulting to 0 and
     0.01.

 -- Function File: imnoise (A, "poisson")
     Creates poisson noise in the image using the intensity value of
     each pixel as mean.

 -- Function File: imnoise (A, "salt & pepper", DENSITY)
     Create "salt and pepper"/"lost pixels" in DENSITY*100 percent of
     the image.  DENSITY defaults to 0.05.

 -- Function File: imnoise (A, "speckle", VARIANCE)
     Multiplicative gaussian noise with B = A + A * noise with mean 0
     and VARIANCE defaulting to 0.04.

     See also: rand, randn, randp.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
Add noise to image.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 470
 -- Function File: imopen (IMG, SE)
     Perform morphological opening.

     The matrix IMG must be numeric while SE can be a:
        * strel object;
        * array of strel objects as returned by '@strel/getsequence';
        * matrix of 0's and 1's.

     The opening corresponds to an erosion followed by a dilation of
     IMG, using the same SE, i.e., it is equivalent to:
          imdilate (imerode (img, se), se);

     See also: imdilate, imerode, imclose.




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



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
impad


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1814
 -- Function File: impad( A, XPAD, YPAD, [PADDING, [CONST]])
     Pad (augment) a matrix for application of image processing
     algorithms.

     This function has been deprecated in favor of 'padarray' and will
     be removed from future versions of image package.  Notes when
     making the conversion:

        * padarray will take the order of the padding arguments by order
          of dimension, i.e., swap XPAD and YPAD.  Use 'padarray (A,
          [YPAD XPAD], ...)'

        * There is no "ones" as PADDING option.  Simply set the value 1
          as padding value.

        * If XPAD and IPAD are 2 element vectors with different values,
          they will need to be replaced by two calls to padarray as
          follow:
               B = padarray (A, [ypad(1) xpad(1)], "pre");
               B = padarray (B, [ypad(2) xpad(2)], "post");

        * The "reflect" PADDING option of 'padarray' is different from
          'impad'.  Use "circular" instead.

     Pads the input image A with XPAD(1) elements from left, XPAD(2),
     elements from right, YPAD(1) elements from above and YPAD(2)
     elements from below.  Values of padding elements are determined
     from the optional arguments PADDING and CONST.  PADDING is one of

     "zeros"
          pad with zeros (default)

     "ones"
          pad with ones

     "constant"
          pad with a value obtained from the optional fifth argument
          const

     "symmetric"
          pad with values obtained from A so that the padded image
          mirrors A starting from edges of A

     "reflect"
          same as symmetric, but the edge rows and columns are not used
          in the padding

     "replicate"
          pad with values obtained from A so that the padded image
          repeates itself in two dimensions




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
Pad (augment) a matrix for application of image processing algorithms.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
imperspectivewarp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1691
 -- Function File: WARPED = imperspectivewarp(IM, P, INTERP, BBOX,
          EXTRAPVAL)
 -- Function File: [ WARPED , VALID] = imperspectivewarp(...)
     Applies the spatial perspective homogeneous transformation P to the
     image IM.  The transformation matrix P must be a 3x3 homogeneous
     matrix, or 2x2 or 2x3 affine transformation matrix.

     The optional argument METHOD defines the interpolation method to be
     used.  All methods supported by 'interp2' can be used.  By default,
     the 'linear' method is used.

     For MATLAB compatibility, the methods 'bicubic' (same as 'cubic'),
     'bilinear' and 'triangle' (both the same as 'linear') are also
     supported.

     By default the resulting image contains the entire warped image.
     In some situation you only parts of the warped image.  The argument
     BBOX controls this, and can be one of the following strings
     '"loose"'
          The entire warped result is returned.  This is the default
          behavior.
     '"crop"'
          The central part of the image of the same size as the input
          image is returned.
     '"same"'
          The size and coordinate system of the input image is keept.

     All values of the result that fall outside the original image will
     be set to EXTRAPVAL.  For images of class 'double' EXTRAPVAL
     defaults to 'NA' and for other classes it defaults to 0.

     The optional output VALID is a matrix of the same size as WARPED
     that contains the value 1 in pixels where WARPED contains an
     interpolated value, and 0 in pixels where WARPED contains an
     extrapolated value.

     See also: imremap, imrotate, imresize, imshear, interp2.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
Applies the spatial perspective homogeneous transformation P to the
image IM.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1007
 -- Function File: impixel ()
 -- Function File: impixel (IMG, X, Y)
 -- Function File: impixel (IND, MAP, X, Y)
 -- Function File: impixel (XDATA, YDATA, IMG, X, Y)
 -- Function File: impixel (XDATA, YDATA, IND, MAP, X, Y)
 -- Function File: [X, Y, P] = impixel (...)
     Get pixel values.

     For any image IMG, or indexed image IND with colormap MAP, returns
     the pixel values at the image coordinates X and Y.

     The 2 element vectors XDATA and YDATA can be used to set an
     alternative coordinate system.

     If more than one output argument is requested, also returns the X
     and Y coordinates for the image.

        * The pixel values are always returned in RGB style triples,
          even when IMG is a grayscale image.

        * The value for pixel coordinates outside the image limits is
          NaN.

        * Because a floating-point is required to represent a NaN, the
          pixel values will be of class double if input is double, and
          single otherwise.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
Get pixel values.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1397
 -- Function File: WARPED = imremap(IM, XI, YI)
 -- Function File: WARPED = imremap(IM, XI, YI, INTERP, EXTRAPVAL)
 -- Function File: [ WARPED , VALID ] = imremap(...)
     Applies any geometric transformation to the image IM.

     The arguments XI and YI are lookup tables that define the resulting
     image
          WARPED(y,x) = IM(YI(y,x), XI(y,x))
     where IM is assumed to be a continuous function, which is achieved
     by interpolation.  Note that the image IM is expressed in a (X,
     Y)-coordinate system and not a (row, column) system.

     The optional argument METHOD defines the interpolation method to be
     used.  All methods supported by 'interp2' can be used.  By default,
     the 'linear' method is used.

     For MATLAB compatibility, the methods 'bicubic' (same as 'cubic'),
     'bilinear' and 'triangle' (both the same as 'linear') are also
     supported.

     All values of the result that fall outside the original image will
     be set to EXTRAPVAL.  For images of class 'double' EXTRAPVAL
     defaults to 'NA' and for other classes it defaults to 0.

     The optional output VALID is a matrix of the same size as WARPED
     that contains the value 1 in pixels where WARPED contains an
     interpolated value, and 0 in pixels where WARPED contains an
     extrapolated value.

     See also: imperspectivewarp, imrotate, imresize, imshear, interp2.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Applies any geometric transformation to the image IM.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1205
 -- Function File: imresize (IM, SCALE)
 -- Function File: imresize (IM, [M N])
 -- Function File: imresize (..., METHOD)
     Resize image with interpolation

     Scales the image IM by a factor SCALE or into the size M rows by N
     columns.  For example:

          imresize (im, 1);    # return the same image as input
          imresize (im, 1.5);  # return image 1.5 times larger
          imresize (im, 0.5);  # return image with half the size
          imresize (im, 2);    # return image with the double size
          imresize (im, [512 610]); # return image of size 512x610

     If M or N is 'NaN', it will be determined automatically so as to
     preserve aspect ratio.

     The optional argument METHOD defines the interpolation method to be
     used.  All methods supported by 'interp2' can be used.  By default,
     the 'cubic' method is used.

     For MATLAB compatibility, the methods 'bicubic' (same as 'cubic'),
     'bilinear' and 'triangle' (both the same as 'linear') are also
     supported.

     bicubic (default)
          Same as 'cubic'.

     bilinear
          Same as 'linear'.

     triangle
          Same as 'linear'.

     See also: imremap, imrotate, interp2.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Resize image with interpolation



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1551
 -- Function File: imrotate (IMGPRE, THETA, METHOD, BBOX, EXTRAPVAL)
     Rotate image about its center.

     Input parameters:

     IMGPRE a gray-level image matrix

     THETA the rotation angle in degrees counterclockwise

     The optional argument METHOD defines the interpolation method to be
     used.  All methods supported by 'interp2' can be used.  In
     addition, Fourier interpolation by decomposing the rotation matrix
     into 3 shears can be used with the 'fourier' method.  By default,
     the 'nearest' method is used.

     For MATLAB compatibility, the methods 'bicubic' (same as 'cubic'),
     'bilinear' and 'triangle' (both the same as 'linear') are also
     supported.

     BBOX
          "loose" grows the image to accommodate the rotated image
          (default).
          "crop" rotates the image about its center, clipping any part
          of the image that is moved outside its boundaries.

     EXTRAPVAL sets the value used for extrapolation.  The default value
     is 'NA' for images represented using doubles, and 0 otherwise.
     This argument is ignored of Fourier interpolation is used.

     Output parameters:

     IMGPOST the rotated image matrix

     H the homography mapping original to rotated pixel coordinates.  To
     map a coordinate vector c = [x;y] to its rotated location, compute
     round((H * [c; 1])(1:2)).

     VALID a binary matrix describing which pixels are valid, and which
     pixels are extrapolated.  This output is not available if Fourier
     interpolation is used.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Rotate image about its center.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
imrotate_Fourier


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 309
 -- Function File: imrotate_Fourier (M, THETA, METHOD, BBOX)
     Rotation of a 2D matrix.

     _This function has been deprecated and will be removed.  Instead,
     use 'imrotate' and select the 'fourier' method.  This function is
     actually just a wrapper to that function._

     See also: imrotate.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
Rotation of a 2D matrix.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1179
 -- Function File: imshear (M, AXIS, ALPHA, BBOX)
     Applies a shear to the image M.

     The argument M is either a matrix or an RGB image.

     AXIS is the axis along which the shear is to be applied, and can be
     either 'x' or 'y'.  For example, to shear sideways is to shear
     along the 'x' axis.  Choosing 'y' causes an up/down shearing.

     ALPHA is the slope of the shear.  For an 'x' shear, it is the
     horizontal shift (in pixels) applied to the pixel above the center.
     For a 'y' shear, it is the vertical shift (in pixels) applied to
     the pixel just to the right of the center pixel.

     NOTE: ALPHA does NOT need to be an integer.

     BBOX can be one of 'loose', 'crop' or 'wrap'.  'loose' allows the
     image to grow to accommodate the new transformed image.  'crop'
     keeps the same size as the original, clipping any part of the image
     that is moved outside the bounding box.  'wrap' keeps the same size
     as the original, but does not clip the part of the image that is
     outside the bounding box.  Instead, it wraps it back into the
     image.

     If called with only 3 arguments, BBOX is set to 'loose' by default.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Applies a shear to the image M.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7383
 -- Function File: J = imsmooth(I, NAME, OPTIONS)
     Smooth the given image using several different algorithms.

     The first input argument I is the image to be smoothed.  If it is
     an RGB image, each color plane is treated separately.  The variable
     NAME must be a string that determines which algorithm will be used
     in the smoothing.  It can be any of the following strings

     "Gaussian"
          Isotropic Gaussian smoothing.  This is the default.
     "Average"
          Smoothing using a rectangular averaging linear filter.
     "Disk"
          Smoothing using a circular averaging linear filter.
     "Median"
          Median filtering.
     "Bilateral"
          Gaussian bilateral filtering.
     "Perona & Malik"
     "Perona and Malik"
     "P&M"
          Smoothing using nonlinear isotropic diffusion as described by
          Perona and Malik.
     "Custom Gaussian"
          Gaussian smoothing with a spatially varying covariance matrix.

     In all algorithms the computation is done in double precision
     floating point numbers, but the result has the same type as the
     input.  Also, the size of the smoothed image is the same as the
     input image.

     *Isotropic Gaussian smoothing*

     The image is convolved with a Gaussian filter with spread SIGMA.
     By default SIGMA is 0.5, but this can be changed.  If the third
     input argument is a scalar it is used as the filter spread.

     The image is extrapolated symmetrically before the convolution
     operation.

     *Rectangular averaging linear filter*

     The image is convolved with N by M rectangular averaging filter.
     By default a 3 by 3 filter is used, but this can e changed.  If the
     third input argument is a scalar N a N by N filter is used.  If the
     third input argument is a two-vector '[N, M]' a N by M filter is
     used.

     The image is extrapolated symmetrically before the convolution
     operation.

     *Circular averaging linear filter*

     The image is convolved with circular averaging filter.  By default
     the filter has a radius of 5, but this can e changed.  If the third
     input argument is a scalar R the radius will be R.

     The image is extrapolated symmetrically before the convolution
     operation.

     *Median filtering*

     Each pixel is replaced with the median of the pixels in the local
     area.  By default, this area is 3 by 3, but this can be changed.
     If the third input argument is a scalar N the area will be N by N,
     and if it's a two-vector [N, M] the area will be N by M.

     The image is extrapolated symmetrically before the filtering is
     performed.

     *Gaussian bilateral filtering*

     The image is smoothed using Gaussian bilateral filtering as
     described by Tomasi and Manduchi [2].  The filtering result is
     computed as
          J(x0, y0) = k * SUM SUM I(x,y) * w(x, y, x0, y0, I(x0,y0), I(x,y))
                           x   y
     where 'k' a normalisation variable, and
          w(x, y, x0, y0, I(x0,y0), I(x,y))
            = exp(-0.5*d([x0,y0],[x,y])^2/SIGMA_D^2)
              * exp(-0.5*d(I(x0,y0),I(x,y))^2/SIGMA_R^2),
     with 'd' being the Euclidian distance function.  The two paramteres
     SIGMA_D and SIGMA_R control the amount of smoothing.  SIGMA_D is
     the size of the spatial smoothing filter, while SIGMA_R is the size
     of the range filter.  When SIGMA_R is large the filter behaves
     almost like the isotropic Gaussian filter with spread SIGMA_D, and
     when it is small edges are preserved better.  By default SIGMA_D is
     2, and SIGMA_R is 10/255 for floating points images (with integer
     images this is multiplied with the maximal possible value
     representable by the integer class).

     The image is extrapolated symmetrically before the filtering is
     performed.

     *Perona and Malik*

     The image is smoothed using nonlinear isotropic diffusion as
     described by Perona and Malik [1].  The algorithm iteratively
     updates the image using

          I += lambda * (g(dN).*dN + g(dS).*dS + g(dE).*dE + g(dW).*dW)

     where 'dN' is the spatial derivative of the image in the North
     direction, and so forth.  The function G determines the behaviour
     of the diffusion.  If g(x) = 1 this is standard isotropic
     diffusion.

     The above update equation is repeated ITER times, which by default
     is 10 times.  If the third input argument is a positive scalar,
     that number of updates will be performed.

     The update parameter LAMBDA affects how much smoothing happens in
     each iteration.  The algorithm can only be proved stable is LAMBDA
     is between 0 and 0.25, and by default it is 0.25.  If the fourth
     input argument is given this parameter can be changed.

     The function G in the update equation determines the type of the
     result.  By default 'G(D) = exp(-(D./K).^2)' where K = 25.  This
     choice gives privileges to high-contrast edges over low-contrast
     ones.  An alternative is to set 'G(D) = 1./(1 + (D./K).^2)', which
     gives privileges to wide regions over smaller ones.  The choice of
     G can be controlled through the fifth input argument.  If it is the
     string '"method1"', the first mentioned function is used, and if it
     is "METHOD2" the second one is used.  The argument can also be a
     function handle, in which case the given function is used.  It
     should be noted that for stability reasons, G should return values
     between 0 and 1.

     The following example shows how to set 'G(D) = exp(-(D./K).^2)'
     where K = 50.  The update will be repeated 25 times, with LAMBDA =
     0.25.

          G = @(D) exp(-(D./50).^2);
          J = imsmooth(I, "p&m", 25, 0.25, G);

     *Custom Gaussian Smoothing*

     The image is smoothed using a Gaussian filter with a spatially
     varying covariance matrix.  The third and fourth input arguments
     contain the Eigenvalues of the covariance matrix, while the fifth
     contains the rotation of the Gaussian.  These arguments can be
     matrices of the same size as the input image, or scalars.  In the
     last case the scalar is used in all pixels.  If the rotation is not
     given it defaults to zero.

     The following example shows how to increase the size of an Gaussian
     filter, such that it is small near the upper right corner of the
     image, and large near the lower left corner.

          [LAMBDA1, LAMBDA2] = meshgrid (linspace (0, 25, columns (I)), linspace (0, 25, rows (I)));
          J = imsmooth (I, "Custom Gaussian", LAMBDA1, LAMBDA2);

     The implementation uses an elliptic filter, where only neighbouring
     pixels with a Mahalanobis' distance to the current pixel that is
     less than 3 are used to compute the response.  The response is
     computed using double precision floating points, but the result is
     of the same class as the input image.

     *References*

     [1] P. Perona and J. Malik, "Scale-space and edge detection using
     anisotropic diffusion", IEEE Transactions on Pattern Analysis and
     Machine Intelligence, 12(7):629-639, 1990.

     [2] C. Tomasi and R. Manduchi, "Bilateral Filtering for Gray and
     Color Images", Proceedings of the 1998 IEEE International
     Conference on Computer Vision, Bombay, India.

     See also: imfilter, fspecial.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Smooth the given image using several different algorithms.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1218
 -- Function File: OUT = imsubtract (A, B)
 -- Function File: OUT = imsubtract (A, B, CLASS)
     Subtract image or constant to an image.

     If A and B are two images of same size and class, B is subtracted
     to A.  Alternatively, if B is a floating-point scalar, its value is
     subtracted to the image A.

     The class of OUT will be the same as A unless A is logical in which
     case OUT will be double.  Alternatively, it can be specified with
     CLASS.

     _Note 1_: you can force output class to be logical by specifying
     CLASS.  This is incompatible with MATLAB which will _not_ honour
     request to return a logical matrix.

     _Note 2_: the values are truncated to the mininum value of the
     output class.

     _Note 3_: values are truncated before the operation so if input
     images are unsigned integers and the request output class is a
     signed integer, it may lead to unexpected results:

          imsubtract (uint8 ([23 190]), uint8 ([24 200]), "int8")
               => -1  0

     Because both 190 and 200 were truncated to 127 before subtraction,
     their difference is zero.

     See also: imabsdiff, imadd, imcomplement, imdivide, imlincomb,
     immultiply.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Subtract image or constant to an image.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 621
 -- Function File: imtophat (IMG, SE)
     Perform morphological top hat filtering.

     The matrix IMG must be numeric while SE can be a:
        * strel object;
        * array of strel objects as returned by '@strel/getsequence';
        * matrix of 0's and 1's.

     A top hat transform corresponds to the difference between IMG, and
     the opening of IMG, i.e., it is equivalent to:
          img - imopen (img, se);

     Use 'imbothat' to perform a 'black' or 'closing', top-hat transform
     (is is also known as bottom-hat transform).

     See also: imerode, imdilate, imopen, imclose, imbothat, mmgradm.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
Perform morphological top hat filtering.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
imtransform


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2551
 -- Function File: B = imtransform (A, T)
 -- Function File: B = imtransform (A, T, INTERP)
 -- Function File: B = imtransform (..., PROP, VAL)
 -- Function File: [B, XDATA, YDATA] = imtransform (...)
     Transform image.

     Given an image A in one space, returns an image B resulting from
     the forward transform defined in the transformation structure T.
     An additionnal input argument INTERP, 'bicubic', 'bilinear'
     (default) or 'nearest', specifies the interpolation method to be
     used.  Finally, the transformation can be tuned using PROP/VAL
     pairs.  The following properties are supported:

     "udata"
          Specifies the input space horizontal limits.  Value must be a
          two elements vector [minval maxval].  Default: [1 columns(A)]

     "vdata"
          Specifies the input space vertical limits.  Value must be a
          two elements vector [minval maxval].  Default: [1 rows(A)]

     "xdata"
          Specifies the requiered output space horizontal limits.  Value
          must be a two elements vector [minval maxval].  Default:
          estimated using udata, vdata and findbounds function.

     "ydata"
          Specifies the requiered output space vertical limits.  Value
          must be a two elements vector [minval maxval].  Default:
          estimated using udata, vdata and findbounds function.

     "xyscale"
          Specifies the output scale in outputspace_units/pixel.  If a
          scalar is provided, both vertical and horizontal dimensions
          are scaled the same way.  If VAL is a two element vector, it
          must indicate consecutively horizontal and vertical scales.
          Default value is computed using the input space scale provided
          that the number of pixel of any dimension of the output image
          does not exceed 20000.

     "size"
          Size of the output image (1-by-2 vector).  Overrides the
          effect of "xyscale" property.

     "fillvalues"
          Color of the areas where no interpolation where possible, e.g.
          when coorfinates of points in the output space are out of the
          limits of the input space.  VAL must be coherent with the
          input image format: for grayscale and indexed images (2D) VAL
          must be scalar, for RGB (n-by-m-by-3) VAL must be a 3 element
          vector.

     The actual output limits, XDATA and YDATA vectors, are returned
     respectively as second and third output variables.

     See also: maketform, cp2tform, tforminv, tformfwd, findbounds.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
Transform image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
imtranslate


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 314
 -- Function File: Y = imtranslate (M, X, Y)
 -- Function File: Y = imtranslate (M, X, Y, BBOX)
     Translate a 2D image by (x,y) using Fourier interpolation.

     M is a matrix, and is translated to the right by X pixels and
     translated up by Y pixels.

     BBOX can be either 'crop' or 'wrap' (default).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Translate a 2D image by (x,y) using Fourier interpolation.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 499
 -- Function File: intlut (A, LUT)
     Convert matrix from look up table (LUT).

     Replaces the values from the matrix A with the corresponding value
     from the look up table LUT (this is the grayscale equivalent to an
     indexed image).

     A and LUT must be of the same class, and uint8, uint16, or int16.
     LUT must have exactly 256 elements for class uint8, and 65536 for
     classes uint16 and int16.  Output is of same class as LUT.

     See also: ind2gray, ind2rgb, rgb2ind.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
Convert matrix from look up table (LUT).



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 666
 -- Function File: iptcheckconn (CON, FUNC_NAME, VAR_NAME, POS)
     Check if argument is valid connectivity.

     If CON is not a valid connectivity argument, gives a properly
     formatted error message.  FUNC_NAME is the name of the function to
     be used on the error message, VAR_NAME the name of the argument
     being checked (for the error message), and POS the position of the
     argument in the input.

     A valid connectivity argument must be either double or logical.  It
     must also be either a scalar from set [1 4 6 8 18 26], or a
     symmetric matrix with all dimensions of size 3, with only 0 or 1 as
     values, and 1 at its center.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
Check if argument is valid connectivity.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
iptcheckmap


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 601
 -- Function File: iptcheckmap (IN, FUNC_NAME, VAR_NAME, POS)
     Check if argument is valid colormap.

     If IN is not a valid colormap, gives a properly formatted error
     message.  FUNC_NAME is the name of the function to be used on the
     error message, VAR_NAME the name of the argument being checked (for
     the error message), and POS the position of the argument in the
     input.

     A valid colormap is a 2-D matrix with 3 columns of doubles with
     values between 0 and 1 (inclusive), that refer to the intensity
     levels of red, green and blue.

     See also: colormap.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Check if argument is valid colormap.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 803
 -- Function File: iptchecknargin (LOW, HIGH, IN, FUNC_NAME)
     Checks for correct number of arguments.

     This function has been deprecated.  For an exact replacement, use
     'narginchk (LOW, HIGH)' instead.  Alternatively, 'print_usage' is
     able to provide an even better error message provided that there is
     documentation for the function:

          if (nargin < min_inputs || nargin > max_inputs)
            print_usage ();
          endif

     This function returns an error unless IN is between the values of
     LOW and HIGH.  It does nothing otherwise.  They all must be non
     negative scalar integers.  HIGH can also be Inf.

     FUNC_NAME is the name of the function to be used on the error
     message.

     See also: error, nargin, nargout, narginchk, nargoutchk.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Checks for correct number of arguments.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 692
 -- Function File: VALID = iptcheckstrs (IN, VALID_STR, FUNC_NAME,
          VAR_NAME, POS)
     Check if argument is a valid string.

     This function has been deprecated.  Use 'validatestring' instead.

     If IN is not a string, present in the cell array of strings
     VALID_STR gives a properly formatted error message.  Otherwise,
     VALID is the matched string.  The performed matching is
     case-insensitive.

     FUNC_NAME is the name of the function to be used on the error
     message, VAR_NAME the name of the argument being checked (for the
     error message), and POS the position of the argument in the input.

     See also: strcmp, strcmpi, find, validatestring.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Check if argument is a valid string.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 412
 -- Function File: ORD = iptnum2ordinal (NUM)
     Convert number to ordinal string.

     NUM must be a real positive integer which will be converted to a
     string with its ordinal form ORD.

          iptnum2ordinal (1)
                => first
          iptnum2ordinal (12)
               => twelfth
          iptnum2ordinal (21)
               => 21st

     See also: num2str, sprintf, int2str, mat2str.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
Convert number to ordinal string.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2302
 -- Function File: RECON = iradon (PROJ, THETA, INTERP, FILTER, SCALING,
          OUTPUT_SIZE)

     Performs filtered back-projection on the projections in PROJ to
     reconstruct an approximation of the original image.

     PROJ should be a matrix whose columns are projections of an image
     (or slice).  Each element of THETA is used as the angle (in
     degrees) that the corresponding column of PROJ was projected at.
     If THETA is omitted, it is assumed that projections were taken at
     evenly spaced angles between 0 and 180 degrees.  THETA can also be
     a scalar, in which case it is taken as the angle between
     projections if more than one projection is provided.

     INTERP determines the type of interpolation that is used in the
     back-projection.  It must be one of the types accepted by
     'interp1', and defaults to 'Linear' if it is omitted.

     FILTER and SCALING determine the type of rho filter to apply.  See
     the help for 'rho_filter' for their use.

     OUTPUT_SIZE sets the edge length of the output image (it is always
     square).  This argument does not scale the image.  If it is
     omitted, the length is taken to be
     2 * floor (size (proj, 1) / (2 * sqrt (2))).

     If PROJ was obtained using 'radon', there is no guarantee that the
     reconstructed image will be exactly the same size as the original.

 -- Function File: [RECON, FILT] = iradon (...)

     This form also returns the filter frequency response in the vector
     FILT.

     Performs filtered back-projection in order to reconstruct an image
     based on its projections.

     Filtered back-projection is the most common means of reconstructing
     images from CT scans.  It is a two step process: First, each of the
     projections is filtered with a 'rho filter', so named due to its
     frequency domain definition, which is simply |rho|, where rho is
     the radial axis in a polar coordinate system.  Second, the filtered
     projections are each 'smeared' across the image space.  This is the
     back-projection part.

     Usage example:

            P = phantom ();
            projections = radon (P, 1:179);
            reconstruction = iradon (filtered_projections, 1:179, 'Spline', 'Hann');
            figure, imshow (reconstruction, [])




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Performs filtered back-projection on the projections in PROJ to
reconstruct an a



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
isbw


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 830
 -- Function File: isbw (IMG)
 -- Function File: isbw (IMG, LOGIC)
     Return true if IMG is a black and white image.

     A variable can be considered a black and white image if it is a
     non-sparse matrix of size MxNx1xK, and depending on the string
     LOGIC, defined as:

     "logical" (default)
          IMG must be of class logical.

     "non-logical"
          all values in IMG are either 1 or 0.

     *Note:* despite their suggestive names, the functions isbw, isgray,
     isind, and isrgb, are ambiguous since it is not always possible to
     distinguish between those image types.  For example, an uint8
     matrix can be both a grayscale and indexed image.  They are good to
     dismiss input as an invalid image type, but not for identification.

     See also: im2bw, isgray, isind, islogical, isrgb.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Return true if IMG is a black and white image.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 724
 -- Function File: isgray (IMG)
     Return true if IMG is an indexed image.

     A variable can be considered a grayscale image if it is a
     non-sparse matrix of size MxNx1xK and:

        * is of class double and all values are in the range [0, 1] or
          NaN;
        * is of class uint8, uint16 or int16.

     *Note:* despite their suggestive names, the functions isbw, isgray,
     isind, and isrgb, are ambiguous since it is not always possible to
     distinguish between those image types.  For example, an uint8
     matrix can be both a grayscale and indexed image.  They are good to
     dismiss input as an invalid image type, but not for identification.

     See also: gray2ind, isbw, isind, isrgb.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Return true if IMG is an indexed image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
isind


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 743
 -- Function File: isind (IMG)
     Return true if IMG is an indexed image.

     A variable can be considered an indexed image if it is a non-sparse
     matrix of size MxNx1xK and:

        * is of class double but all values are integers greater than or
          equal to 1;
        * is of class uint8 or uint16.

     *Note:* despite their suggestive names, the functions isbw, isgray,
     isind, and isrgb, are ambiguous since it is not always possible to
     distinguish between those image types.  For example, an uint8
     matrix can be both a grayscale and indexed image.  They are good to
     dismiss input as an invalid image type, but not for identification.

     See also: ind2gray, ind2rgb, isbw, isgray, isindex, isrgb.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Return true if IMG is an indexed image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
isrgb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 716
 -- Function File: isrgb (IMG)
     Return true if IMG is a RGB image.

     A variable can be considered a RGB image if it is a non-sparse
     matrix of size MxNx3xK and:

        * is of class double and all values are in the range [0, 1] or
          NaN;
        * is of class uint8, or uint16.

     *Note:* despite their suggestive names, the functions isbw, isgray,
     isind, and isrgb, are ambiguous since it is not always possible to
     distinguish between those image types.  For example, an uint8
     matrix can be both a grayscale and indexed image.  They are good to
     dismiss input as an invalid image type, but not for identification.

     See also: rgb2gray, rgb2ind, isbw, isgray, isind.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Return true if IMG is a RGB image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
label2rgb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1409
 -- Function File: label2rgb (L)
 -- Function File: label2rgb (L, CMAP)
 -- Function File: label2rgb (L, CMAP, BACKGROUND)
 -- Function File: label2rgb (L, CMAP, BACKGROUND, ORDER)
     Convert labeled image into RGB.

     The labeled image L is converted into an RGB image using the
     colormap CMAP.  The label number of each region is used to select
     the color from CMAP which can be specified as:

        * N-by-3 colormap matrix where N must be larger than or equal to
          the highest label number;
        * name of a function that returns a colormap;
        * handle for a function that returns a colormap (defaults to
          'jet').

     In a labeled image, zero valued pixels are considered background
     and are colored according to the color BACKGROUND.  It can be
     specified as an RGB triplet values (3 element vector of values
     between 0 and 1), or by name:

        * "w" or "white" (default)
        * "b" or "blue".
        * "c" or "cyan".
        * "g" or "green".
        * "k" or "black".
        * "m" or "magenta".
        * "r" or "red".
        * "y" or "yellow".

     The option ORDER must be a string with values "shuffle" or
     "noshuffle" (default).  If shuffled, the colors in CMAP are
     permuted randomly before the image conversion.

     The output RGB image is always of class uint8.

     See also: bwconncomp, bwlabel, colormap, ind2rgb.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Convert labeled image into RGB.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
labelmatrix


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 517
 -- Function File: labelmatrix (CC)
     Create labelled matrix from bwconncomp structure.

     Uses the structure as returned by the 'bwconncomp' function to
     create a label matrix, where each individual object is assigned a
     positive number.  A value of zero corresponds to the background.

     The class of the output matrix is dependent on the number of
     objects, being uint, uint16, uint32, or double, whichever is
     enough.

     See also: bwconncomp, bwlabel, bwlabeln, label2rgb, rgb2label.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Create labelled matrix from bwconncomp structure.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 825
 -- Function File: LUT = makelut (FUN, N)
 -- Function File: LUT = makelut (FUN, N, P1, P2, ...)
     Create a lookup table which can be used by applylut.

     lut = makelut(fun,n) returns a vector which can be used by applylut
     as a lookup table.

     FUN can be a function object as created by inline, or simply a
     string which contains the name of a function.  FUN should accept a
     N-by-N matrix whose elements are binary (0 or 1) and returns an
     scalar (actually anything suitable to be included in a vector).

     makelut calls FUN with all possible matrices and builds a vector
     with its result, suitable to be used by applylut.  The length of
     this vector is 2^(N^2), so 16 for 2-by-2 and 512 for 3-by-3.

     makelut also passes parameters P1, P2, ....  to FUN.

     See also: applylut.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Create a lookup table which can be used by applylut.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
maketform


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2792
 -- Function File: T = maketform (TTYPE, TMAT)
 -- Function File: T = maketform (TTYPE, INC, OUTC)
 -- Function File: T = maketform ("custom", NDIMS_IN, NDIMS_OUT,
          FORWARD_FCN, INVERSE_FCN, TDATA)
     Create structure for spatial transformations.

     Returns a transform structure containing fields NDIMS_IN,
     NDIMS_OUT, FORWARD_FCN, INVERSE_FCN and TDATA.  The content of each
     field depends on the requested transform type TTYPE:

     "projective"
          A ndims_in = N -> NDIMS_OUT = N projective transformation
          structure is returned.  The second input argument TMAT must be
          a (N+1)-by-(N+1) transformation matrix.  The (N+1)th column
          must contain projection coefficients.  As an example a two
          dimentionnal transform from [x y] coordinates to [u v]
          coordinates is represented by a transformation matrix defined
          so that:

               [xx yy zz] = [u v 1] * [a d g;
                                       b e h;
                                       c f i]
               [x y] =  [xx./zz yy./zz];

          Alternatively the transform can be specified using a
          quadilateral coordinates (typically the 4 corners of the
          image) in the input space (INC, 4-by-ndims_in matrix) and in
          the output space (OUTC, 4-by-ndims_out matrix).  This is
          equivalent to building the transform using 'T = cp2tform (INC,
          OUTC, "projective")'.

     "affine"
          Affine is a subset of projective transform (see above).  A
          NDIMS_IN = N -> NDIMS_OUT = N affine transformation structure
          is returned.  The second input argument TMAT must be a
          (N+1)-by-(N+1) or (N+1)-by-(N) transformation matrix.  If
          present, the (N+1)th column must contain [zeros(N,1); 1] so
          that projection is suppressed.

          Alternatively the transform can be specified a using a
          triangle coordinates (typically the 3 corners of the image) in
          the input space (INC, 3-by-ndims_in matrix) and in the output
          space (OUTC, 3-by-ndims_out matrix).  This is equivalent to
          building the transform using "T = cp2tform (INC, OUTC,
          'affine')".

     "custom"
          For user defined transforms every field of the transform
          structure must be supplied.  The prototype of the transform
          functions, FORWARD_FCN and INVERSE_FCN, should be X' =
          transform_fcn (X, T). X and X' are respectively p-by-ndims_in
          and p-by-ndims_out arrays for forward_fcn and reversed for
          inverse_fcn.  The argument T is the transformation structure
          which will contain the user supplied transformation matrix
          TDATA.

     See also: tformfwd, tforminv, cp2tform.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Create structure for spatial transformations.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1189
 -- Function File: I = mat2gray (M)
 -- Function File: I = mat2gray (M, [MIN MAX])
     Convert a matrix to an intensity image.

     The returned matrix I is a grayscale image, of double class and in
     the range of values [0, 1].  The optional arguments MIN and MAX
     will set the limits of the conversion; values in M below MIN and
     above MAX will be set to 0 and 1 on I respectively.

     MAX and MIN default to the maximum and minimum values of M.

     If MIN is larger than MAX, the 'inverse' will be returned.  Values
     in M above MAX will be set to 0 while the ones below MIN will be
     set to 1.

     *Caution:* For compatibility with MATLAB, if MIN and MAX are equal
     (either from being actually being set manually or automatically
     calculated from the M min and max values, Octave's mat2gray will
     truncate all values between [0 1].  For example

          mat2gray ([-2 0 0.5 0.9 5], [2 2])
               => [0  0  0.5  0.9  1]
          mat2gray ([0.5 0.5 0.5])
               => [0.5  0.5  0.5]
          mat2gray ([4 4 4])
               => [1  1  1]

     See also: gray2ind, ind2gray, rgb2gray, im2double, im2uin16,
     im2uint8, im2int16.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Convert a matrix to an intensity image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
mean2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 228
 -- Function File: M= mean2 (I)
     Compute the mean value of the 2D image I.

     Note that M will be of class double, independently of the input
     class.  This is equivalent to 'mean (I(:))'.

     See also: mean, std2.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Compute the mean value of the 2D image I.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1063
 -- Function File: medfilt2 (A)
 -- Function File: medfilt2 (A, NHOOD)
 -- Function File: medfilt2 (A, [M N])
 -- Function File: medfilt2 (..., PAD)
     Two dimensional median filtering.

     Replaces elements of A with the median of their neighbours as
     defined by the true elements of logical matrix NHOOD or by a matrix
     of size M by N.  The default NHOOD is a 3 by 3 matrix of true
     elements.

          ## median filtering specifying neighborhood dimensions
          medfilt2 (img)         # default is [3 3]
          medfilt2 (img, [3 1])  # a 3x1 vector
          medfilt2 (img, [5 5])  # 5 element wide square

          ## median filtering specifying neighborhood
          medfilt2 (img, true (5)) # same as [5 5]
          nhood = logical ([0 1 0
                            1 1 1
                            0 1 0]);
          medfilt2 (img, nhood)    # 3 element wide cross

     The optional variable PAD defines the padding used in augmenting
     the borders of A.  See 'padarray' for details.

     See also: ordfilt2, ordfiltn.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
Two dimensional median filtering.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1188
 -- Function File: mmgradm (IMG)
 -- Function File: mmgradm (IMG, SE_DIL)
 -- Function File: mmgradm (IMG, SE_DIL, SE_ERO)
     Perform morphological gradient.

     The matrix IMG must be numeric whose gradients is calculated, while
     SE_DIL and SE_ERO are the structuring elements for the dilation and
     erosion respectively.  They can be a:
        * strel object;
        * array of strel objects as returned by '@strel/getsequence';
        * matrix of 0's and 1's.

     The SE_DIL and SE_ERO default to the elementary cross, i.e.:
          [ 0 1 0
            1 1 1
            0 1 0];

     The basic morphological gradient corresponds to a matrix erosion
     subtracted to its dilation, which is equivalent to:
          imdilate (img, se_dil) - imerode (img, se_ero)

     To perform the half-gradients by erosion or dilation, or the
     internal or external gradients, simply pass an empty matrix as
     structuring element:
          mmgradm (img, [], se_ero) # half-gradient by erosion or internal gradient
          mmgradm (img, se_dil, []) # half-gradient by dilation or external gradient

     See also: imerode, imdilate, imopen, imclose, imtophat, imbothat.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1918
 -- Function File: montage (I)
 -- Function File: montage (X, CMAP)
 -- Function File: montage (FILENAMES)
 -- Function File: montage (..., PARAM1, VALUE1, ...)
 -- Function File: H = montage (...)
     Create montage from multiple images.

     The created montage will be of a single large image built from the
     4D matrix I.  I must be a MxNx1xP or MxNx3xP matrix for a grayscale
     and binary, or RGB image with P frames.

     Alternatively, X can be a MxNx1xP indexed image with P frames, with
     the colormap CMAP, or a cell array of FILENAMES for multiple
     images.

     DisplayRange
          A vector with 2 or 0 elements setting the highest and lowest
          value for display range.  It is interpreted like the LIMITS
          argument to 'imshow'.

     Indices
          A vector with the image indices to be displayed.  Defaults to
          all images, i.e., '1:size (I, 4)'.

     Size
          Sets the montage layout size.  Must be a 2 element vector
          setting [NROWS NCOLS].  A value of NaN will be adjusted to the
          required value to display all images.  If both values are NaN
          (default), it will find the most square layout capable of
          displaying all of the images.

     MarginColor
          Sets color for the margins between panels.  Defaults to white.
          Must be a 1 or 3 element vector for grayscale or RGB images.

     MarginWidth
          Sets width for the margins between panels.  Defaults to 0
          pixels.  Note that the margins are only between panels.

     BackgroundColor
          Sets the montage background color.  Defaults to black.  Must
          be a 1 or 3 element vector for grayscale or RGB images.  This
          will only affect montages with more panels than images.

     The optional return value H is a graphics handle to the created
     plot.

     See also: imshow, padarray, permute, reshape.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Create montage from multiple images.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1833
 -- Function File: nlfilter (A, BLOCK_SIZE, FUNC)
 -- Function File: nlfilter (A, BLOCK_SIZE, FUNC, ...)
 -- Function File: nlfilter (A, "indexed", ...)
     Process matrix in sliding blocks with user-supplied function.

     Executes the function FUN on each sliding block of size BLOCK_SIZE,
     taken from the matrix A.  Both the matrix A, and the block can have
     any number of dimensions.  This function is specially useful to
     perform sliding/moving window functions such as moving average.

     The output will have the same dimensions A, each one of its values
     corresponding to the processing of a block centered at the same
     coordinates in A, with A being padded with zeros for the borders
     (see below for indexed images).  In case any side of the block is
     of even length, the center is considered at indices 'floor
     ([BLOCK_SIZE/2] + 1)'.

     The argument FUNC must be a function handle that takes matrices of
     size BLOCK_SIZE as input and returns a single scalar.  Any extra
     input arguments to 'nlfilter' are passed to FUNC after the block
     matrix.

     If A is an indexed image, the second argument should be the string
     "indexed" so that any required padding is done correctly as done by
     'im2col'.

     _Note_: if FUNC is a column compression function, i.e., it acts
     along a column to return a single value, consider using 'colfilt'
     which usually performs faster.  If FUNC makes use of the colon
     operator to select all elements in the block, e.g., if FUNC looks
     anything like '@(x) sum (x(:))', it is a good indication that
     'colfilt' should be used.  In addition, many sliding block
     operations have their own specific implementations (see help text
     of 'colfilt' for a list).

     See also: blockproc, col2im, colfilt, im2col.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Process matrix in sliding blocks with user-supplied function.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 637
 -- Function File: normxcorr2 (TEMPLATE, IMG)
 -- Function File: normxcorr2 (TEMPLATE, IMG)
     Compute the normalized 2D cross-correlation.

     Returns the normalized cross correlation matrix of TEMPLATE and IMG
     so that a value of 1 corresponds to the positions of IMG that match
     TEMPLATE perfectly.

     _Note_: this function exists only for MATLAB compatibility and is
     just a wrapper to the 'coeff' option of 'xcorr2' with the arguments
     inverted.  See the 'xcorr2' documentation for more details.  Same
     results can be obtained with 'xcorr2 (img, template, "coeff")'

     See also: conv2, corr2, xcorr2.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Compute the normalized 2D cross-correlation.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 428
 -- Function File: ordfilt2 (A, NTH, DOMAIN)
 -- Function File: ordfilt2 (A, NTH, DOMAIN, S)
 -- Function File: ordfilt2 (..., PADDING)
     Two dimensional ordered filtering.

     This function exists only for MATLAB compatibility as is just a
     wrapper to the 'ordfiltn' which performs the same function on N
     dimensions.  See 'ordfiltn' help text for usage explanation.

     See also: medfilt2, padarray, ordfiltn.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Two dimensional ordered filtering.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 799
 -- Function File: ordfiltn (A, NTH, DOMAIN)
 -- Function File: ordfiltn (A, NTH, DOMAIN, S)
 -- Function File: ordfiltn (..., PADDING)
     N dimensional ordered filtering.

     Ordered filter replaces an element of A with the NTH element
     element of the sorted set of neighbours defined by the logical
     (boolean) matrix DOMAIN.  Neighbour elements are selected to the
     sort if the corresponding element in the DOMAIN matrix is true.

     The optional variable S is a matrix of size(DOMAIN).  Values of S
     corresponding to nonzero values of domain are added to values
     obtained from A when doing the sorting.

     Optional variable PADDING determines how the matrix A is padded
     from the edges.  See 'padarray' for details.

     See also: medfilt2, padarray, ordfilt2.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
N dimensional ordered filtering.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2063
 -- Function File: padarray (A, PADSIZE)
 -- Function File: padarray (..., PADVAL)
 -- Function File: padarray (..., PATTERN)
 -- Function File: padarray (..., DIRECTION)
     Pad array or matrix.

     Adds padding of length PADSIZE, to a numeric matrix A.  PADSIZE
     must be a vector of non-negative values, each of them defining the
     length of padding to its corresponding dimension.  For example, if
     PADSIZE is [4 5], it adds 4 rows (1st dimension) and 5 columns (2nd
     dimension), to both the start and end of A.

     If there's less values in PADSIZE than number of dimensions in A,
     they're assumed to be zero.  Singleton dimensions of A are also
     padded accordingly (except when PATTERN is "reflect").

     The values used in the padding can either be a scalar value PADVAL,
     or the name of a specific PATTERN.  Available patterns are:

     "zeros" (default)
          Pads with the value 0 (same as passing a PADVAL of 0).  This
          is the default.

     "circular"
          Pads with a circular repetition of elements in A (similar to
          tiling A).

     "replicate"
          Pads replicating the values at the border of A.

     "symmetric"
          Pads with a mirror reflection of A.

     "reflect"
          Same as "symmetric", but the borders are not used in the
          padding.  Because of this, it is not possible to pad singleton
          dimensions.

     By default, padding is done in both directions.  To change this,
     DIRECTION can be one of the following values:

     "both" (default)
          Pad each dimension before the first element of A the number of
          elements defined by PADSIZE, and the same number again after
          the last element.  This is the default.

     "pre"
          Pad each dimension before the first element of A the number of
          elements defined by PADSIZE.

     "post"
          Pad each dimension after the last element of A the number of
          elements defined by PADSIZE.

     See also: cat, flipdim, resize, prepad, postpad.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
Pad array or matrix.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2555
 -- Function File: P = phantom ()
 -- Function File: P = phantom (MODEL)
 -- Function File: P = phantom (E)
 -- Function File: P = phantom (..., N)
 -- Function File: [P, E] = phantom (...)
     Create computational phantom head.

     A phantom is a known object (either real or purely mathematical)
     that is used for testing image reconstruction algorithms.  The
     Shepp-Logan phantom is a popular mathematical model of a cranial
     slice, made up of a set of overlaying ellipses.  This allows
     rigorous testing of computed tomography (CT) algorithms as it can
     be analytically transformed with the radon transform (see the
     functions 'radon' and 'iradon').

     The phantom P, is created by overlaying ellipses as defined by the
     matrix E or one of the standard MODELs, in a square of size N by N
     (defaults to 256).

     The available standard MODELs (use the output argument E to inspect
     the details of the different ellipses) are:

     "Sheep-Logan"
          This is the original Sheep-Logan model with 10 ellipses as
          described in Table 1 of 'Shepp, Lawrence A., and Benjamin F.
          Logan. "The Fourier reconstruction of a head section." Nuclear
          Science, IEEE Transactions on 21, no. 3 (1974): 21-43.'

     "Modified Shepp-Logan" (default)
          A modification of the original Shepp-Logan model to give a
          better contrast, as described in Table B.3 of 'Toft, Peter
          Aundal. "The radon transform-theory and implementation." PhD
          diss., Department of Mathematical Modelling, Technical
          University of Denmark, 1996.'

     A 6 column matrix E can be used to generate a custom image by
     superimposing arbitrary ellipses.  Each row defines a single
     ellipse, with each column for the values of {I, a, b, x0, y0, phi}:

     I
          is the additive intensity of the ellipse

     a
          is the length of the major axis

     b
          is the length of the minor axis

     x0
          is the horizontal offset of the centre of the ellipse

     y0
          is the vertical offset of the centre of the ellipse

     phi
          is the counterclockwise rotation of the ellipse in degrees,
          measured as the angle between the x axis and the ellipse major
          axis.

     The image bounding box in the algorithm is {[-1, -1], [1, 1]}, so
     the values of a, b, x0, y0 should all be specified with this in
     mind.

     Example:

          P = phantom (512);
          imshow (P);

     See also: iradon, radon.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Create computational phantom head.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
poly2mask


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1184
 -- Function File: BW = poly2mask (X,Y,M,N)
     Convert a polygon to a region mask.

     BW=poly2mask(x,y,m,n) converts a polygon, specified by a list of
     vertices in X and Y and returns in a M-by-N logical mask BW the
     filled polygon.  Region inside the polygon is set to 1, values
     outside the shape are set to 0.

     X and Y should always represent a closed polygon, first and last
     points should be coincident.  If they are not poly2mask will close
     it for you.  If X or Y are fractional they are nearest integer.

     If all the polygon or part of it falls outside the masking area
     (1:m,1:n), it is discarded or clipped.

     This function uses scan-line polygon filling algorithm as described
     in http://www.cs.rit.edu/~icss571/filling/ with some minor
     modifications: capability of clipping and scan order, which can
     affect the results of the algorithm (algorithm is described not to
     reach ymax, xmax border when filling to avoid enlarging shapes).
     In this function we scan the image backwards (we begin at ymax and
     end at ymin), and we don't reach ymin, xmin, which we believe
     should be compatible with MATLAB.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
Convert a polygon to a region mask.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2393
 -- Function File: S = qtdecomp (I)
 -- Function File: S = qtdecomp (I, THRESHOLD)
 -- Function File: S = qtdecomp (I, THRESHOLD, MINDIM)
 -- Function File: S = qtdecomp (I, THRESHOLD, [MINDIM MAXDIM])
 -- Function File: S = qtdecomp (I, FUN)
 -- Function File: S = qtdecomp (I, FUN, P1, P2, ...)
     Performs quadtree decomposition.

     qtdecomp decomposes a square image I into four equal-sized blocks.
     Then it performs some kind of test on each block to decide if it
     should decompose them further.  This process is repeated
     iteratively until there's no block left to be decomposed.

     Note that blocks are not decomposed if their dimensions are not
     even.

     The output is a sparse matrix whose non-zero elements determine the
     position of the block (the element is at top-left position in the
     block) and size of each block (the value of the element determines
     length of a side of the square-shaped block).

     S = qtdecomp(I) decomposes an intensity image I as described above.
     By default it doesn't split a block if all elements are equal.

     S = qtdecomp(I, threshold) decomposes an image as decribed, but
     only splits a block if the maximum value in the block minus the
     minimum value is greater than THRESHOLD, which is a value between 0
     and 1.  If I is of class uint8, THRESHOLD is multiplied by 255
     before use.  Also, ifI is of class uint16, THRESHOLD is multiplied
     by 65535.

     S = qtdecomp(I, threshold, mindim) decomposes an image using the
     THRESHOLD as just described, but doesn't produce blocks smaller
     than mindim.

     S = qtdecomp(I, threshold, [mindim maxdim]) decomposes an image as
     described, but produces blocks that can't be bigger than maxdim.
     It decomposes to maxdim even if it isn't needed if only THRESHOLD
     was considered.

     S = qtdecomp(I, fun) decomposes an image I and uses function FUN to
     decide if a block should be splitted or not.  FUN is called with a
     m-by-m-by-k array of m-by-m blocks to be considered, and should
     return a vector of size k, whose elements represent each block in
     the stacked array.  FUN sets the corresponding value to 1 if the
     block should be split, and 0 otherwise.

     S = qtdecomp(I, fun, ...) behaves as qtdecomp(I, fun) but passes
     extra parameters to FUN.

     See also: qtgetblk, qtsetblk.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
Performs quadtree decomposition.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 908
 -- Function File: [VALS] = qtgetblk (I, S, DIM)
 -- Function File: [VALS,IDX] = qtgetblk (I, S, DIM)
 -- Function File: [VALS,R,C] = qtgetblk (I, S, DIM)
     Obtain block values from a quadtree decomposition.

     [vals]=qtgetblk(I,S,dim) returns a dim-by-dim-by-k array in VALS
     which contains the dim-by-dim blocks in the quadtree decomposition
     (S, which is returned by qtdecomp) of I.  If there are no blocks,
     an empty matrix is returned.

     [vals,idx]=qtgetblk(I,S,dim) returns VALS as described above.  In
     addition, it returns IDX, a vector which contains the linear
     indices of the upper left corner of each block returned (the same
     result as find(full(S)==dim)).

     [vals,r,c]=qtgetblk(I,S,dim) returns VALS as described, and two
     vectors, R and C, which contain the row and column coordinates of
     the blocks returned.

     See also: qtdecomp, qtsetblk.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Obtain block values from a quadtree decomposition.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 415
 -- Function File: J = qtsetblk (I, S, DIM, VALS)
     Set block values in a quadtree decomposition.

     J=qtsetblk(I,S,dim,vals) sets all the DIM-by-DIM blocks in the
     quadtree decomposition (S returned by qtdecomp) of I to DIM-by-DIM
     blocks in VALS, which is itself a DIM-by-DIM-by-k array.  k is the
     number of DIM-by-DIM blocks in the quadtree decomposition.

     See also: qtdecomp, qtgetblk.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Set block values in a quadtree decomposition.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
radon


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 350
 -- Function File: [RT,XP] = radon( I, THETA)
 -- Function File: [RT,XP] = radon( I)

     Calculates the 2D-Radon transform of the matrix I at angles given
     in THETA.  To each element of THETA corresponds a column in RT.
     The variable XP represents the x-axis of the rotated coordinate.
     If THETA is not defined, then 0:179 is assumed.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
Calculates the 2D-Radon transform of the matrix I at angles given in
THETA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
rangefilt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 868
 -- Function File: R = rangefilt (IM)
 -- Function File: R = rangefilt (IM, DOMAIN)
 -- Function File: R = rangefilt (IM, DOMAIN, PADDING, ...)
     Computes the local intensity range in a neighbourhood around each
     pixel in an image.

     The intensity range of the pixels of a neighbourhood is computed as

          R = max (X) - min (X)

     where X is the value of the pixels in the neighbourhood,

     The neighbourhood is defined by the DOMAIN binary mask.  Elements
     of the mask with a non-zero value are considered part of the
     neighbourhood.  By default a 3 by 3 matrix containing only non-zero
     values is used.

     At the border of the image, extrapolation is used.  By default
     symmetric extrapolation is used, but any method supported by the
     'padarray' function can be used.

     See also: paddarray, entropyfilt, stdfilt.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Computes the local intensity range in a neighbourhood around each pixel
in an im



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 674
 -- Function File: EXIF = readexif( FILENAME, THUMBNAIL)
     Read EXIF information from JPEG image data.

     The exif tag information are returned in the EXIF data structure.
     Integer ratios are expressed as column vector.  For example, a
     focal number of 2.8 is expressed as FNumber=[28; 10].  Otherwise
     all data are returned by the type as specified in the IFD
     structures.

     The filename for the thumbnail image is optional.  If given, the
     thumbnail jpeg image will be stored to file THUMBNAIL.

     Reference: JEITA CP-3451, Exchangeable image file format for
     digital still cameras: Exif Version 2.2

     See also: imwrite, imfinfo.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Read EXIF information from JPEG image data.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
regionprops


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3003
 -- Function File: PROPS = regionprops (BW)
 -- Function File: PROPS = regionprops (BW, PROPERTIES, ...)
 -- Function File: PROPS = regionprops (L, PROPERTIES, ...)
 -- Function File: PROPS = regionprops (..., I, PROPERTIES, ...)
     Compute object properties in a binary image.

     'regionprops' computes various properties of the individual objects
     (as identified by 'bwlabel') in the binary image BW.  The result is
     a structure array containing an entry per property per object.

     The optional grayscale image I is used for pixel value measurements
     (MaxIntensity, MinIntensity, MeanIntensity, PixelValues and
     WeightedCentroid).

     The following properties can be computed:

     "Area"
          The number of pixels in the object.

     "BoundingBox"
     "bounding_box"
          The bounding box of the object.  This is represented as a
          4-vector where the first two entries are the x and y
          coordinates of the upper left corner of the bounding box, and
          the two last entries are the width and the height of the box.

     "Centroid"
          The center coordinate of the object.

     "EulerNumber"
     "euler_number"
          The Euler number of the object (see 'bweuler' for details).

     "Extent"
          The area of the object divided by the area of the bounding
          box.

     "FilledArea"
     "filled_area"
          The area of the object including possible holes.

     "FilledImage"
     "filled_image"
          A binary image with the same size as the object's bounding box
          that contains the object with all holes removed.

     "Image"
          An image with the same size as the bounding box that contains
          the original pixels.

     "MaxIntensity"
     "max_intensity"
          The maximum intensity inside the object.

     "MeanIntensity"
     "mean_intensity"
          The mean intensity inside the object.

     "MinIntensity"
     "min_intensity"
          The minimum intensity inside the object.

     "Perimeter"
          The length of the boundary of the object.

     "PixelIdxList"
     "pixel_idx_list"
          The indices of the pixels in the object.

     "PixelList"
     "pixel_list"
          The actual pixel values inside the object.  This is only
          useful for grey scale images.

     "PixelValues"
     "pixel_values"
          The pixel values inside the object represented as a vector.

     "WeightedCentroid"
     "weighted_centroid"
          The centroid of the object where pixel values are used as
          weights.

     The requested properties can either be specified as several input
     arguments or as a cell array of strings.  As a short-hand it is
     also possible to give the following strings as arguments.

     "basic"
          The following properties are computed: "Area", "Centroid" and
          "BoundingBox".  This is the default.

     "all"
          All properties are computed.

     See also: bwlabel, bwperim, bweuler.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Compute object properties in a binary image.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 478
 -- Function File: GRAY = rgb2gray (RGB)
     Convert RGB image or colormap to grayscale.

     If RGB is an RGB image, the conversion to grayscale is weighted
     based on the luminance values (see 'rgb2ntsc').  Supported classes
     are single, double, uint8 and uint16.

     If RGB is a colormap it is converted into the YIQ space of ntsc.
     The luminance value (Y) is taken to create a gray colormap.

     See also: mat2gray, ntsc2rgb, rgb2ind, rgb2ntsc, rgb2ycbcr.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Convert RGB image or colormap to grayscale.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
rgb2ycbcr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 961
 -- Function File: YCBCRMAP = rgb2ycbcr (CMAP)
 -- Function File: YCBCR = rgb2ycbcr (RGB)
 -- Function File: ... = rgb2ycbcr (..., [KB KR])
 -- Function File: ... = rgb2ycbcr (..., STANDARD)
     Convert RGB values to YCbCr.

     The convertion changes the image RGB or colormap CMAP, from the RGB
     color model to YCbCr (luminance, chrominance blue, and chrominance
     red).  RGB must be of class double, single, uint8, or uint16.

     The formula used for the conversion is dependent on two constants,
     KB and KR which can be specified individually, or according to
     existing standards:

     "601" (default)
          According to the ITU-R BT.601 (formerly CCIR 601) standard.
          Its values of KB and KR are 0.114 and 0.299 respectively.
     "709" (default)
          According to the ITU-R BT.709 standard.  Its values of KB and
          KR are 0.0722 and 0.2116 respectively.

     See also: hsv2rgb, ntsc2rgb, rgb2hsv, rgb2ntsc.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
Convert RGB values to YCbCr.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2520
 -- Function File: FILTERED = rho_filter (PROJ, TYPE, SCALING)

     Filters the parallel ray projections in the columns of PROJ,
     according to the filter type chosen by TYPE.  TYPE can be chosen
     from
        * 'none'
        * 'Ram-Lak' (default)
        * 'Shepp-Logan'
        * 'Cosine'
        * 'Hann'
        * 'Hamming'

     If given, SCALING determines the proportion of frequencies below
     the nyquist frequency that should be passed by the filter.  The
     window function is compressed accordingly, to avoid an abrupt
     truncation of the frequency response.

 -- Function File: [FILTERED, FILTER] = rho_filter (...)

     This form also returns the frequency response of the filter in the
     vector FILTER.

     Performs rho filtering on the parallel ray projections provided.

     Rho filtering is performed as part of the filtered back-projection
     method of CT image reconstruction.  It is the filtered part of the
     name.  The simplest rho filter is the Ramachadran-Lakshminarayanan
     (Ram-Lak), which is simply |rho|, where rho is the radial component
     of spatial frequency.  However, this can cause unwanted
     amplification of noise, which is what the other types attempt to
     minimise, by introducing roll-off into the response.  The Hann and
     Hamming filters multiply the standard response by a Hann or Hamming
     window, respectively.  The cosine filter is the standard response
     multiplied by a cosine shape, and the Shepp-Logan filter multiplies
     the response with a sinc shape.  The 'none' filter performs no
     filtering, and is included for completeness and to enable
     incorporating this function easily into scripts or functions that
     may offer the ability to choose to apply no filtering.

     This function is designed to be used by the function 'iradon', but
     has been exposed to facilitate custom inverse radon transforms and
     to more clearly break down the process for educational purposes.
     The operations
              filtered = rho_filter (proj);
              reconstruction = iradon (filtered, 1, 'linear', 'none');
     are exactly equivalent to
              reconstruction = iradon (proj, 1, 'linear', 'Ram-Lak');

     Usage example:
            P = phantom ();
            projections = radon (P);
            filtered_projections = rho_filter (projections, 'Hamming');
            reconstruction = iradon (filtered_projections, 1, 'linear', 'none');
            figure, imshow (reconstruction, [])




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Filters the parallel ray projections in the columns of PROJ, according
to the fi



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 551
 -- Function File: BW = roicolor (A, LOW, HIGH)
 -- Function File: BW = roicolor (A,V)
     Select a Region Of Interest of an image based on color.

     BW = roicolor(A,low,high) selects a region of interest (ROI) of an
     image A returning a black and white image in a logical array (1 for
     pixels inside ROI and 0 outside ROI), which is formed by all pixels
     whose values lie within the colormap range specified by [LOW HIGH].

     BW = roicolor(A,v) selects a region of interest (ROI) formed by all
     pixels that match values in V.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Select a Region Of Interest of an image based on color.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
std2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 147
 -- Function File: S = std2 (I)
     Returns the standard deviation for a 2d real type matrix.  Uses
     'std (I(:))'

     See also: mean2,std.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Returns the standard deviation for a 2d real type matrix.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1074
 -- Function File: S = stdfilt (IM)
 -- Function File: S = stdfilt (IM, DOMAIN)
 -- Function File: S = stdfilt (IM, DOMAIN, PADDING, ...)
     Computes the local standard deviation in a neighbourhood around
     each pixel in an image.

     The standard deviation of the pixels of a neighbourhood is computed
     as

          S = sqrt ((sum (X - MU).^2)/(N-1))

     where MU is the mean value of the pixels in the neighbourhood, N is
     the number of pixels in the neighbourhood.  So, an unbiased
     estimator is used.

     The neighbourhood is defined by the DOMAIN binary mask.  Elements
     of the mask with a non-zero value are considered part of the
     neighbourhood.  By default a 3 by 3 matrix containing only non-zero
     values is used.

     At the border of the image, extrapolation is used.  By default
     symmetric extrapolation is used, but any method supported by the
     'padarray' function can be used.  Since extrapolation is used, one
     can expect a lower deviation near the image border.

     See also: std2, paddarray, entropyfilt.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Computes the local standard deviation in a neighbourhood around each
pixel in an



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1939
 -- Function File: LOW_HIGH = stretchlim (I,TOL)
 -- Function File: LOW_HIGH = stretchlim (I)
 -- Function File: LOW_HIGH = stretchlim (RGB,TOL)
 -- Function File: LOW_HIGH = stretchlim (RGB)
     Finds limits to contrast stretch an image

     'LOW_HIGH=stretchlim(I,TOL)' returns a vector LOW_HIGH which
     contains a pair of intensities which can be used in 'imadjust' to
     stretch the contrast of an image, first of them will be lower value
     ('imadjust' would assign 0 to it) and second is the upper bound.
     TOL specifies the fraction of the image to saturate at lower and
     upper limits.  It can be a vector of length 2: '[LOW_FRACT,
     HIGH_FRACT]', or it can be a scalar, in that case '[LOW_FRACT,
     HIGH_FRACT]=[TOL, 1-TOL]'.

     TOL can't be larger than 0.50 and for TOL=0 then
     'LOW_HIGH=[min(I(:)), max(I(:))]'.

     'LOW_HIGH=stretchlim(I)' behaves as described but defaults TOL to
     '[0.01, 0.99]'.

     'LOW_HIGH=stretchlim(RGB,TOL)' returns a 2-by-3 matrix in LOW_HIGH
     of lower and upper values to saturate for each plane of the RGB
     image in M-by-N-by-3 array RGB.  TOL is a vector or a scalar, as
     described above, and the same fractions are applied for each plane.

     'LOW_HIGH=stretchlim(RGB)' uses '[0.01, 0.99]' as default value for
     TOL.

     *Notes:*

     Values in LOW_HIGH are of type double and comprised between 0 and 1
     regardless class of input image.

     *Compatibility notes:*

        * int* and uint* types are still not implemented (waiting for
          support in Octave 2.1.58).
        * This function tries to find limits that are nearer to saturate
          requested interval.  So, for instance, if you requested a 5%
          and it has to choose between discarding a 1% and a 7%, it will
          choose the later despite being more than requested.  This
          should be test against MATLAB behaviour.

     See also: imadjust.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Finds limits to contrast stretch an image



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 403
 -- Function File: [UV] = tformfwd (T, XY)
 -- Function File: [U, V] = tformfwd (T, X, Y)

     Given to dimensionnal coordinates from one space, returns two
     dimensionnal coordinates in the other space, as defined in the
     transform structure T.  Input and output coordinates may be gigen
     either as a n-by-2 arrays, or as two n-by-1 vectors.

     See also: maketform, cp2tform, tforminv.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Given to dimensionnal coordinates from one space, returns two
dimensionnal coord



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 406
 -- Function File: [UV] = tforminv (T, XY)
 -- Function File: [U, V] = tforminvfwd (T, X, Y)

     Given to dimensionnal coordinates from one space, returns two
     dimensionnal coordinates in the other space, as defined in the
     transform structure T.  Input and output coordinates may be gigen
     either as a n-by-2 arrays, or as two n-by-1 vectors.

     See also: maketform, cp2tform, tformfwd.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Given to dimensionnal coordinates from one space, returns two
dimensionnal coord



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
tiff_tag_read


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2208
 -- Function File: [VALUE, OFFSET] = tiff_tag_read (FILE, TAG)
 -- Function File: [VALUE, OFFSET] = tiff_tag_read (FILE, TAG, IFD)
 -- Function File: [VALUE, OFFSET] = tiff_tag_read (FILE, TAG, "all")
     Read value of TAGs from TIFF files.

     FILE must be a TIFF file and TAG should be a tag ID. To check
     multiple tags, TAG can be a vector.  If IFD is supplied, only those
     IFDs (Image File Directory) will be read.  As with TAG, multiple
     IFDs can be checked by using a vector or with the string 'all'.  By
     default, only the first IFD is read.

     VALUE and OFFSET will be a matrix with a number of rows and columns
     equal to the number of TAGs and IFDs requested.  The index relate
     to the same order as the input.  OFFSET has the same structure as
     VALUE and when equal to 1 its matching value on VALUE will be an
     offset to a position in the file.

     TAGs that can't be found will have a value of 0 and the
     corresponding OFFSET will be 2.

     If an error occurs when reading FILE (such as lack of permissions
     of file is not a TIFF file), OFFSET is set to -1 and VALUE contains
     the error message.

     See the following examples:
          ## read value of tag 258 on IFD 1 (`off' will be 1 if `val' is an offset or 2 if not found)
          [val, off] = tiff_tag_read (filepath, 258);

          ## read value 258, 262, 254 o IFD 1 (`val' and `off' will be a 1x3 matrix)
          [val, off] = tiff_tag_read (filepath, [258 262 254]);
          if (off(1) == -1), error ("something happpened: %s", val); endif
          off(2,1)   # will be 1 if val(2,1) is an offset to a file position or 2 if tag was not found
          val(2,1)   # value of tag 262 on IFD 1

          ## read value 258, 262, 254 on the first 10 IFDs 1 (`val' and `off' will be a 1x10 matrix)
          [val, off] = tiff_tag_read (filepath, [258 262 254], 1:10);
          val(2,5)   # value of tag 262 on IFD 5

          ## read value 258, 262, 254 o IFD 1 (`val' and `off' will be a 1x3 matrix)
          [val, off] = tiff_tag_read (filepath, [258 262 254], "all");
          val(2,end)   # value of tag 262 on the last IFD

     See also: imread, imfinfo, readexif.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
Read value of TAGs from TIFF files.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 314
 -- Function File: B = uintlut (A, LUT)
     Computes matrix B by using A as an index to lookup table LUT.

     This function has been deprecated.  Use 'intlut' instead.

     B = uintlut(A, LUT) calculates a matrix B by using LUT as a lookup
     table indexed by values in A.

     B class is the same as LUT.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Computes matrix B by using A as an index to lookup table LUT.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1170
 -- Function File: RGB = wavelength2rgb (WAVELENGTH)
 -- Function File: RGB = wavelength2rgb (WAVELENGTH, CLASS)
 -- Function File: RGB = wavelength2rgb (WAVELENGTH, CLASS, GAMMA)
     Convert wavelength in nm into an RGB value set.

     Given a N-dimensional matrix WAVELENGTH with color values in nm,
     returns a RGB image with N+3 dimensions.

          wavelength2rgb (400)
              => [0.51222 0.00000 0.70849]

          wavelength2rgb ([400 410])
              => 0.51222   0.49242
              => 0         0
              => 0.70849   0.85736

     The RGB class can be specified with CLASS.  Possible values are
     double (default), single, uint8, uint16, and int16.

          wavelength2rgb (400)
              => 0.51222  0.00000  0.70849

          wavelength2rgb (400, "uint8")
              => 131    0  181

     The luminance of colors can be adjusted with GAMMA which must a
     scalar value in the range [0 1].  Defaults to 0.8.

     Reference:
        * 
          <http://stackoverflow.com/questions/2374959/algorithm-to-convert-any-positive-integer-to-an-rgb-value>
        * <http://www.midnightkite.com/color.html> per Dan Bruton




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Convert wavelength in nm into an RGB value set.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
ycbcr2rgb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 997
 -- Function File: CMAP = ycbcr2rgb (YCBCRMAP)
 -- Function File: RGB = ycbcr2rgb (YCBCR)
 -- Function File: ... = ycbcr2rgb (..., [KB KR])
 -- Function File: ... = ycbcr2rgb (..., STANDARD)
     Convert YCbCr color space to RGB.

     The convertion changes the image YCBCR or colormap YCBCRMAP, from
     the YCbCr (luminance, chrominance blue, and chrominance red) color
     space to RGB values.  YCBCR must be of class double, single, uint8,
     or uint16.

     The formula used for the conversion is dependent on two constants,
     KB and KR which can be specified individually, or according to
     existing standards:

     "601" (default)
          According to the ITU-R BT.601 (formerly CCIR 601) standard.
          Its values of KB and KR are 0.114 and 0.299 respectively.
     "709" (default)
          According to the ITU-R BT.709 standard.  Its values of KB and
          KR are 0.0722 and 0.2116 respectively.

     See also: hsv2rgb, ntsc2rgb, rgb2hsv, rgb2ntsc, rgb2ycbcr.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
Convert YCbCr color space to RGB.