--- /dev/null
+# Created by Octave 3.6.1, Mon Mar 12 21:54:04 2012 UTC <root@t61>
+# name: cache
+# type: cell
+# rows: 3
+# columns: 95
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+applylut
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 554
+ -- 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: 832
+ -- Function File: SIZ = bestblk ([M N], K)
+ -- Function File: [MB NB] = bestblk ([M N], K)
+ Calculates the best size of block for block processing.
+
+ `siz=bestblk([m,n],k)' calculates the optimal block size for block
+ processing for a M-by-N image. K is the maximum side dimension of
+ the block. Its default value is 100. SIZ is a row vector which
+ contains row and column dimensions for the block.
+
+ `[mb,nb]=bestblk([m,n],k)' behaves as described above but returns
+ block dimensions to MB and NB.
+
+ *Algorithm:*
+
+ For each dimension (M and N), it follows this algorithm:
+
+ 1.- If dimension is less or equal than K, it returns the dimension
+ value.
+
+ 2.- If not then returns the value between
+ `round(min(dimension/10,k/2))' which minimizes padding.
+
+ See also: blkproc
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 55
+Calculates the best size of block for block processing.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+blkproc
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1441
+ -- Function File: B = blkproc (A, [M,N], FUN)
+ -- Function File: B = blkproc (A, [M,N], FUN, ...)
+ -- Function File: B = blkproc (A, [M,N], [MBORDER,NBORDER], FUN, ...)
+ -- Function File: B = blkproc (A, 'indexed', ...)
+ Processes image in blocks using user-supplied function.
+
+ `B=blkproc(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=blkproc(A,[m,n],fun,...)' behaves as described above but passes
+ extra parameters to function FUN.
+
+ `B=blkproc(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=blkproc(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: 8
+bmpwrite
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 361
+ -- Function File: bmpwrite (X, MAP, FILE)
+ Write the bitmap X into FILE (8-bit indexed uncompressed). The
+ values in X are indices into the given RGB colour MAP.
+
+ -- Function File: bmpwrite (X, FILE)
+ Write the bitmap X into FILE (24-bit truecolor uncompressed). X
+ is an m x n x 3 array of R,G,B integer values in the range 0 to
+ 255.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 58
+Write the bitmap X into FILE (8-bit indexed uncompressed).
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+bwarea
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 425
+ -- Function File: TOTAL = bwarea(BW)
+ Estimates the area of the "on" pixels of BW. If BW is a binary
+ image "on" pixels are defined as pixels valued 1. If BW is a
+ grayscale image "on" pixels is defined as pixels with values
+ larger than zero. This algorithm is not the same as counting the
+ number of "on" pixels as it tries to estimate the area of the
+ original object and not the image object.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 44
+Estimates the area of the "on" pixels of BW.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+bwborder
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 289
+ -- Function File: B = bwborder (IM)
+ Finds the borders of foreground objects in a binary image.
+
+ 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: 1278
+ -- 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: 946
+ -- Function File: CC = bwconncomp (BW)
+ -- Function File: CC = bwconncomp (BW, CONNECTIVITY)
+ Trace the boundaries of objects in a binary image.
+
+ `bwconncomp' traces the boundaries of objects in a binary image BW
+ and returns information about them in a structure with the
+ following fields.
+
+ Connectivity
+ The connectivity used in the boundary tracing.
+
+ ImageSize
+ The size of the image BW.
+
+ NumObjects
+ The number of objects in the image BW.
+
+ PixelIdxList
+ 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.
+
+ The connectivity used in the tracing is by default 4, but can be
+ changed by setting the CONNECTIVITY input parameter to 8. Sadly,
+ this is not yet implemented.
+
+ See also: bwlabel, bwboundaries, ind2sub
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 50
+Trace the boundaries of objects in a binary image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+bwdist
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1229
+ -- Function File: D = bwdist(BW)
+ Computes the distance transform of the image BW. BW should be a
+ binary 2D array, either a Boolean array or a numeric array
+ containing only the values 0 and 1. The return value D is a
+ double matrix of the same size as BW. Elements with value 0 are
+ considered background pixels, elements with value 1 are considered
+ object pixels. The return value for each background pixel is the
+ distance (according to the chosen metric) to the closest object
+ pixel. For each object pixel the return value is 0.
+
+ -- Function File: D = bwdist(BW, METHOD)
+ METHOD is a string to choose the distance metric. Currently
+ available metrics are 'euclidean', 'chessboard', 'cityblock' and
+ 'quasi-euclidean', which may each be abbreviated to any string
+ starting with 'e', 'ch', 'ci' and 'q', respectively. If METHOD is
+ not specified, 'euclidean' is the default.
+
+ -- Function File: [D,C] = bwdist(BW, METHOD)
+ If a second output argument is given, the linear index for the
+ closest object pixel is returned for each pixel. (For object
+ pixels, the index points to the pixel itself.) The return value C
+ is a matrix the same size as BW.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 48
+Computes the distance transform of the image BW.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+bweuler
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 720
+ -- Function File: EUL = bweuler (BW,N)
+ Calculates the Euler number of a binary image.
+
+ EUL=bweuler(BW, N) calculates the Euler number EUL of a binary
+ image BW, which is a scalar whose value is the total number of
+ objects in an image minus the number of holes.
+
+ N can have the values:
+ `4'
+ bweuler will use 4-connected neighbourhood definition.
+
+ `8'
+ bweuler will use 8-connected neighbourhood definition. This
+ is the default value.
+
+ 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: qtgetblk
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 46
+Calculates 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: 6990
+ -- Function File: BW2 = bwmorph (BW,OPERATION)
+ -- Function File: BW2 = bwmorph (BW,OPERATION,N)
+ Perform a morphological operation on a binary image.
+
+ BW2=bwmorph(BW,operation) performs a morphological operation
+ specified by OPERATION on binary image BW. All possible operations
+ and their meaning are specified in a table below.
+
+ BW2=bwmorph(BW,operation,n) performs a morphological operation N
+ times. Keep in mind that it has no sense to apply some operations
+ more than once, since some of them return the same result
+ regardless how many iterations we request. Those return a warning
+ if are called with n>1 and they compute the result for n=1.
+
+ N>1 is actually used for the following operations: diag, dilate,
+ erode, majority, shrink, skel, spur, thicken and thin.
+
+ `'bothat''
+ Performs a bottom hat operation, a closing operation (which
+ is a dilation followed by an erosion) and finally substracts
+ the original image.
+
+ `'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.
+
+ `'close''
+ Performs closing operation, which is a dilation followed by
+ erosion. It uses a ones(3) matrix as structuring element for
+ both operations.
+
+ `'diag''
+ Performs a diagonal fill operation. Sets a pixel to 1 if that
+ eliminates eight-connectivity of the background.
+
+ `'dilate''
+ Performs a dilation operation. It uses ones(3) as structuring
+ element.
+
+ `'erode''
+ Performs an erosion operation. It uses ones(3) as structuring
+ element.
+
+ `'fill''
+ Performs a interior fill operation. Sets a pixel to 1 if all
+ four-connected pixels are 1.
+
+ `'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 five
+ or more pixels in a 3-by-3 window are 1. If not it is set to
+ 0.
+
+ `'open''
+ Performs an opening operation, which is an erosion followed
+ by a dilation. It uses ones(3) as structuring element.
+
+ `'remove''
+ Performs a iterior pixel remove operation. Sets a pixel to 0
+ if all of its four-connected neighbours are 1.
+
+ `'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'.
+
+ `'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.
+
+ 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:*
+ `'fill''
+ Checking MATLAB behaviour is needed because its documentation
+ doesn't make clear if it creates a black pixel if all
+ eight-connected pixels are black or if four-connected suffice
+ (as we do currently following Pratt's book).
+
+ `'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: dilate, erode, makelut, applylut
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 52
+Perform a morphological operation on a binary image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+bwperim
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 401
+ -- Function File: BW2 = bwperim(BW1)
+ -- Function File: BW2 = bwperim(BW1, N)
+ Find the perimeter of objects in binary images.
+
+ A pixel is part of an object perimeter if its value is one and
+ there is at least one zero-valued pixel in its neighborhood.
+
+ By default the neighborhood of a pixel is 4 nearest pixels, but if
+ N is set to 8 the 8 nearest pixels will be considered.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 47
+Find the 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: 431
+ -- 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: 9
+cmpermute
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 768
+ -- Function File: [Y, NEWMAP] = cmpermute (X,MAP)
+ -- Function File: [Y, NEWMAP] = cmpermute (X,MAP,INDEX)
+ Reorders colors in a colormap.
+
+ `[Y,newmap]=cmpermute(X,map)' rearranges colormap MAP randomly
+ returning colormap NEWMAP and generates indexed image Y so that it
+ mantains correspondence between indices and the colormap from
+ original indexed image X (both image and colormap pairs produce
+ the same result).
+
+ `[Y,newmap]=cmpermute(X,map,index)' behaves as described above but
+ instead of sorting colors randomly, it uses INDEX to define the
+ order of the colors in the new colormap.
+
+ *Note:* `index' shouldn't have repeated elements, this function
+ won't explicitly check this, but it will fail if it has.
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 30
+Reorders colors in a colormap.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+cmunique
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1496
+ -- Function File: [Y, NEWMAP] = cmunique (X,MAP)
+ -- Function File: [Y, NEWMAP] = cmunique (RGB)
+ -- Function File: [Y, NEWMAP] = cmunique (I)
+ Finds colormap with unique colors and corresponding image.
+
+ `[Y,newmap]=cmunique(X,map)' returns an indexed image Y along with
+ its associated colormap NEWMAP equivalent (which produce the same
+ image) to supplied X and its colormap MAP; but eliminating any
+ repeated rows in colormap colors and adjusting indices in the
+ image matrix as needed.
+
+ `[Y,newmap]=cmunique(RGB)' returns an indexed image Y along with
+ its associated colormap NEWMAP computed from a true-color image
+ RGB (a m-by-n-by-3 array), where NEWMAP is the smallest colormap
+ possible (alhough it could be as long as number of pixels in
+ image).
+
+ `[Y,newmap]=cmunique(I)' returns an indexed image Y along with its
+ associated colormap NEWMAP computed from a intensity image I,
+ where NEWMAP is the smallest colormap possible (alhough it could
+ be as long as number of pixels in image).
+
+ *Notes:*
+
+ NEWMAP is always a M-by-3 matrix, even if input image is a
+ intensity grey-scale image I (all three RGB planes are assigned
+ the same value).
+
+ NEWMAP is always of class double. If we use a RGB or intensity
+ image of class uint8 or uint16, the colors in the colormap will be
+ of class double in the range [0,1] (they are divided by
+ intmax("uint8") and intmax("uint16") respectively.
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 58
+Finds colormap with unique colors and corresponding image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+col2im
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 959
+ -- Function File: A = col2im (B, [M,N], [MM,NN], BLOCK_TYPE)
+ -- Function File: A = col2im (B, [M,N], [MM,NN])
+ Rearranges matrix columns into blocks.
+
+ `A=col2im(B,[m,n],[mm,nn],block_type)' rearranges columns of
+ matrix B intro blocks in a way controlled by BLOCK_TYPE param,
+ which can take the following values:
+
+ `distinct'
+ It uses M-by-N distinct blocks (which are not overlapped),
+ and are rearranged to form a MM-by-NN matrix A. B's height
+ must be M*N and `col2im' rearranges each column to a M-by-N
+ block and uses them to fill the whole matrix in left-to-right
+ and then up-to-down order.
+
+ `sliding'
+ Is uses M-by-N sliding blocks. It rearranges row vector B to
+ a (MM-M+1)-by-(NN-N+1) matrix A. B must be a
+ 1-by-(MM-M+1)*(NN-N+1).
+
+ `A=col2im(B,[m,n],[mm,nn])' takes `distinct' as a default value
+ for BLOCK_TYPE.
+
+ See also: im2col
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 38
+Rearranges matrix columns into blocks.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+colfilt
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1041
+ -- Function File: colfilt (A, [R, C], [M, N], 'sliding', F,...)
+ Apply filter to matrix blocks
+
+ For each R x C overlapping subblock of A, add a column in matrix C
+ F(C,...) should return a row vector which is then reshaped into a
+ a matrix of size A and returned. A is processed in chunks of size
+ M x N.
+
+ -- Function File: colfilt (A, [R, C], [M, N], 'distinct', F,...)
+ For each R x C non-overlapping subblock of A, add a column in
+ matrix C F(C,...) should return a matrix of size C each column
+ of which is placed back into the subblock from whence it came. A
+ is processed in chunks of size M x N.
+
+ The present version requires that [M, N] divide size(A), but for
+ compatibility it should work even if [M, N] does not divide A. Use
+ the following instead:
+ [r, c] = size(A);
+ padA = zeros (m*ceil(r/m),n*ceil(c/n));
+ padA(1:r,1:c) = A;
+ B = colfilt(padA,...);
+ B = B(1:r,1:c);
+
+ The present version does not handle 'distinct'
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 30
+Apply filter to matrix blocks
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 13
+colorgradient
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 541
+ -- 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: 478
+ -- Function File: CONN = conndef (NUM_DIMS, TYPE)
+ Creates a connectivity array.
+
+ `conn=conndef(num_dims,type)' creates a connectivity array (CONN)
+ of NUM_DIMS dimensions and which type is defined by TYPE as
+ follows:
+ `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))'.
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 29
+Creates a connectivity array.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+corr2
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 184
+ -- Function File: R = corr2 (I,J)
+ Returns the correlation coefficient between I and J. I, J must be
+ real type matrices or vectors of same size.
+
+ See also: cov, std2
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 52
+Returns the correlation coefficient between I and J.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+dilate
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 939
+ -- Function File: BW2 = dilate (BW1,SE)
+ -- Function File: BW2 = dilate (BW1,SE,ALG)
+ -- Function File: BW2 = dilate (BW1,SE,...,N)
+ Perform a dilation morphological operation on a binary image.
+
+ BW2 = dilate(BW1, SE) returns a binary image with the result of a
+ dilation operation on BW1 using neighbour mask SE.
+
+ For each point in BW1, dilate search its neighbours (which are
+ defined by setting to 1 their in SE). If any of its neighbours is
+ on (1), then pixel is set to 1. If all are off (0) then it is set
+ to 0.
+
+ Center of SE is calculated using floor((size(SE)+1)/2).
+
+ Pixels outside the image are considered to be 0.
+
+ BW2 = dilate(BW1, SE, alg) returns the result of a dilation
+ operation using algorithm ALG. Only 'spatial' is implemented at
+ the moment.
+
+ BW2 = dilate(BW1, SE, ..., n) returns the result of N dilation
+ operations on BW1.
+
+ See also: erode
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 61
+Perform a dilation morphological operation on a binary image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 4
+edge
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6148
+ -- 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: 582
+ -- 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: 1194
+ -- 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: 5
+erode
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 919
+ -- Function File: BW2 = erode (BW1,SE)
+ -- Function File: BW2 = erode (BW1,SE,ALG)
+ -- Function File: BW2 = erode (BW1,SE,...,N)
+ Perform an erosion morphological operation on a binary image.
+
+ BW2 = erosion(BW1, SE) returns a binary image with the result of
+ an erosion operation on BW1 using neighbour mask SE.
+
+ For each point in BW1, erode searchs its neighbours (which are
+ defined by setting to 1 their in SE). If all neighbours are on
+ (1), then pixel is set to 1. If any is off (0) then it is set to 0.
+
+ Center of SE is calculated using floor((size(SE)+1)/2).
+
+ Pixels outside the image are considered to be 0.
+
+ BW2 = erode(BW1, SE, alg) returns the result of a erosion operation
+ using algorithm ALG. Only 'spatial' is implemented at the moment.
+
+ BW2 = erosion(BW1, SE, ..., n) returns the result of N erosion
+ operations on BW1.
+
+ See also: dilate
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 61
+Perform an erosion morphological operation on a binary image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+fchcode
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 778
+ -- 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: 353
+ -- 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
+
+
+
+
+
+# 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: 8
+fspecial
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 3242
+ -- 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: 9
+grayslice
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 504
+ -- 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
+
+
+
+
+
+# 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: 542
+ -- Function File: LEVEL= graythresh (I)
+ Compute global image threshold using Otsu's method.
+
+ The output LEVEL is a global threshold (level) that can be used to
+ convert an intensity image to a binary image with `im2bw'. LEVEL
+ is a normalized intensity value that lies in the range [0, 1].
+
+ The function uses Otsu's method, which chooses the threshold to
+ minimize the intraclass variance of the black and white pixels.
+
+ Color images are converted grayscale before LEVEL is computed.
+
+ See also: im2bw
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 51
+Compute global image threshold using Otsu's method.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+histeq
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 282
+ -- Function File: J = histeq (I, N)
+ Histogram equalization of a gray-scale 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
+
+ See also: imhist
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 45
+Histogram equalization of a gray-scale image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 12
+hough_circle
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 776
+ -- 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: 2203
+ -- 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: 213
+ -- Function File: BW = im2bw (I,threshold)
+ -- Function File: BW = im2bw (X,CMAP,threshold)
+ Converts image data types to a black-white (binary) image. The
+ treshold value should be in the range [0,1].
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 58
+Converts image data types to a black-white (binary) image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+im2col
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1681
+ -- Function File: B = im2col (A, [M,N], BLOCK_TYPE)
+ -- Function File: B = im2col (A, [M,N])
+ -- Function File: B = im2col (A, 'indexed', ...)
+ Rearranges image blocks into columns.
+
+ `B=im2col(A, [m, n], blocktype)' rearranges blocks in A into
+ columns in a way that's determined by BLOCK_TYPE, which can take
+ the following values:
+
+ `distinct'
+ Rearranges each distinct M-by-N block in image A into a
+ column of B. Blocks are scanned from left to right and the up
+ to bottom in A, and columns are added to B from left to
+ right. If A's size is not multiple M-by-N it is padded.
+
+ `sliding'
+ Rearranges any M-by-N sliding block of A in a column of B,
+ without any padding, so only sliding blocks which can be
+ built using a full M-by-N neighbourhood are taken. In
+ consequence, B has M*N rows and (MM-M+1)*(NN-N+1) columns
+ (where MM and NN are the size of A).
+
+ This case is thought to be used applying operations on
+ columns of B (for instance using sum(:)), so that result is a
+ 1-by-(MM-M+1)*(NN-N+1) vector, that is what the complementary
+ function `col2im' expects.
+
+ `B=im2col(A,[m,n])' takes `distinct' as a default value for
+ BLOCK_TYPE.
+
+ `B=im2col(A,'indexed',...)' will treat A as an indexed image, so
+ it will pad using 1 if A is double. All other cases (incluing
+ indexed matrices with uint8 and uint16 types and non-indexed
+ images) will use 0 as padding value.
+
+ Any padding needed in 'distinct' processing will be added at right
+ and bottom edges of the image.
+
+ See also: col2im
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 37
+Rearranges image blocks into columns.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 9
+im2double
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 417
+ -- Function File: IM2 = im2double(IM1)
+ Converts the input image to an image of class double.
+
+ If the input image is of class double the output is unchanged. If
+ the input is of class uint8 the result will be converted to doubles
+ and divided by 255, and if the input is of class uint16 the image
+ will be converted to doubles and divided by 65535.
+
+ See also: im2bw, im2uint16, im2uint8
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 53
+Converts the input image to an image of class double.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 9
+im2uint16
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 421
+ -- Function File: IM2 = im2uint16(IM1)
+ Converts the input image to an image of class uint16.
+
+ If the input image is of class uint16 the output is unchanged. If
+ the input is of class uint8 the result will be converted to uint16
+ and multiplied by 257, and if the input is of class double the
+ image will be multiplied by 65535 and converted to uint16.
+
+ See also: im2bw, im2double, im2uint8
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 53
+Converts the input image to an image of class uint16.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+im2uint8
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 413
+ -- Function File: IM2 = im2uint8(IM1)
+ Converts the input image to an image of class uint8.
+
+ If the input image is of class uint8 the output is unchanged. If
+ the input is of class double the result will be multiplied by 255
+ and converted to uint8, and if the input is of class uint16 the
+ image will be divided by 257 and converted to uint8.
+
+ See also: im2bw, im2uint16, im2double
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 52
+Converts the input image to an image of class uint8.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+imadjust
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 3594
+ -- 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: 7
+imclose
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 370
+ -- Function File: B = imclose (A, SE)
+ Perform morphological closing on a given image. The image A must
+ be a grayscale or binary image, and SE must be a structuring
+ element.
+
+ The closing corresponds to a dilation followed by an erosion of
+ the image, i.e.
+ B = imerode(imdilate(A, se), se);
+
+ See also: imdilate, imerode, imclose
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 47
+Perform morphological closing on a given image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 12
+imcomplement
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 344
+ -- Function File: B = imcomplement(A)
+ Computes the complement image. Intuitively this corresponds to the
+ intensity of bright and dark regions being reversed.
+
+ For binary images, the complement is computed as `!A', for floating
+ point images it is computed as `1 - A', and for integer images as
+ `intmax(class(A)) - A'.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 30
+Computes the complement image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+imdilate
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 328
+ -- Function File: B = imdilate (A, SE)
+ Perform morphological dilation on a given image.
+
+ The image A must be a grayscale or binary image, and SE must be a
+ structuring element. Both must have the same class, e.g., if A is a
+ logical matrix, SE must also be logical.
+
+ See also: imerode, imopen, imclose
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 48
+Perform morphological dilation on a given image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+imdither
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1030
+ -- 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: 7
+imerode
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 327
+ -- Function File: B = imerode (A, SE)
+ Perform morphological erosion on a given image.
+
+ The image A must be a grayscale or binary image, and SE must be a
+ structuring element. Both must have the same class, e.g., if A is a
+ logical matrix, SE must also be logical.
+
+ See also: imdilate, imopen, imclose
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 47
+Perform morphological erosion on a given image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+imfilter
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1460
+ -- 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: 7
+imginfo
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 376
+ -- Function File: HW = imginfo (FILENAME)
+ -- Function File: [H, W] = imginfo (FILENAME)
+ Get image size from file FILENAME.
+
+ The output is the size of the image
+ `H'
+ Height of image, in pixels.
+
+ `W'
+ Width of image, in pixels.
+
+ `HW = [H, W]'
+ Height and width of image.
+
+ NOTE : imginfo relies on the 'convert' program.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 34
+Get image size from file FILENAME.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+imhist
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 213
+ -- Function File: imhist (I,N)
+ -- Function File: imhist (I)
+ -- Function File: imhist (X,CMAP)
+ -- Function File: [N,X] = imhist (...)
+ Shows the histogram of an image using hist.
+
+ See also: hist
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 43
+Shows the histogram of an image using hist.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 9
+immaximas
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1102
+ -- 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: 7
+imnoise
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 490
+ -- Function File: B = imnoise (A, TYPE)
+ Adds noise to image in A.
+
+ `imnoise (A, 'gaussian' [, mean [, var]])'
+ additive gaussian noise: B = A + noise defaults to mean=0,
+ var=0.01
+
+ `imnoise (A, 'salt & pepper' [, density])'
+ lost pixels: A = 0 or 1 for density*100% of the pixels
+ defaults to density=0.05, or 5%
+
+ `imnoise (A, 'speckle' [, var])'
+ multiplicative gaussian noise: B = A + A*noise defaults to
+ var=0.04
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 25
+Adds noise to image in A.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+imopen
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 369
+ -- Function File: B = imopen (A, SE)
+ Perform morphological opening on a given image. The image A must
+ be a grayscale or binary image, and SE must be a structuring
+ element.
+
+ The opening corresponds to an erosion followed by a dilation of
+ the image, i.e.
+ B = imdilate(imerode(A, se), se);
+
+ See also: imdilate, imerode, imclose
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 47
+Perform morphological opening on a given image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+impad
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 986
+ -- Function File: impad(A, XPAD, YPAD, [PADDING, [CONST]])
+ Pad (augment) a matrix for application of image processing
+ algorithms.
+
+ 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: 1744
+ -- 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 resulting image WARPED is computed using an interpolation
+ method that can be selected through the INTERP argument. This must
+ be one of the following strings
+ `"nearest"'
+ Nearest neighbor interpolation.
+
+ `"linear"'
+ `"bilinear"'
+ Bilinear interpolation. This is the default behavior.
+
+ `"cubic"'
+ `"bicubic"'
+ Bicubic interpolation.
+
+ 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
+imremap
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1386
+ -- 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 argument INTERP selects the used interpolation method, and
+ most be one of the following strings
+ `"nearest"'
+ Nearest neighbor interpolation.
+
+ `"linear"'
+ `"bilinear"'
+ Bilinear interpolation. This is the default behavior.
+
+ `"cubic"'
+ `"bicubic"'
+ Bicubic interpolation.
+
+ 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: 821
+ -- Function File: B = imresize (A, M)
+ Scales the image A by a factor M using bicubic neighbour
+ interpolation. If M is less than 1 the image size will be reduced,
+ and if M is greater than 1 the image will be enlarged.
+
+ -- Function File: B = imresize (A, M, INTERP)
+ Same as above except INTERP interpolation is performed instead of
+ using nearest neighbour. INTERP can be any interpolation method
+ supported by interp2. By default, bicubic interpolation is used.
+
+ -- Function File: B = imresize (A, [MROW MCOL])
+ Scales the image A to be of size MROWxMCOL.
+
+ -- Function File: B = imresize (A, [MROW MCOL], INTERP)
+ Same as above except INTERP interpolation is performed. INTERP can
+ be any interpolation method supported by interp2.
+
+ See also: imremap, imrotate, interp2
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 71
+Scales the image A by a factor M using bicubic neighbour interpolation.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+imrotate
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 2137
+ -- Function File: imrotate(IMGPRE, THETA, METHOD, BBOX, EXTRAPVAL)
+ Rotation of a 2D matrix about its center.
+
+ Input parameters:
+
+ IMGPRE a gray-level image matrix
+
+ THETA the rotation angle in degrees counterclockwise
+
+ METHOD
+ "nearest" neighbor: fast, but produces aliasing effects
+ (default).
+
+ "bilinear" interpolation: does anti-aliasing, but is slightly
+ slower.
+
+ "bicubic" interpolation: does anti-aliasing, preserves edges
+ better than bilinear interpolation, but gray levels may
+ slightly overshoot at sharp edges. This is probably the best
+ method for most purposes, but also the slowest.
+
+ "Fourier" uses Fourier interpolation, decomposing the
+ rotation matrix into 3 shears. This method often results in
+ different artifacts than homography-based methods. Instead
+ of slightly blurry edges, this method can result in ringing
+ artifacts (little waves near high-contrast edges). However,
+ Fourier interpolation is better at maintaining the image
+ information, so that unrotating will result in an image
+ closer to the original than the other methods.
+
+ 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: 41
+Rotation of a 2D matrix about its center.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 16
+imrotate_Fourier
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 579
+ -- Function File: imrotate(M, THETA, METHOD, BBOX)
+ Rotation of a 2D matrix.
+
+ Applies a rotation of THETA degrees to matrix M.
+
+ The METHOD argument is not implemented, and is only included for
+ compatibility with Matlab. This function uses Fourier
+ interpolation, decomposing the rotation matrix into 3 shears.
+
+ BBOX can be either 'loose' or 'crop'. 'loose' allows the image to
+ grow to accomodate the rotated image. 'crop' keeps the same size
+ as the original, clipping any part of the image that is moved
+ outside the bounding box.
+
+
+
+
+# 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: 1176
+ -- 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 accomodate 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: 7353
+ -- 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: 8
+imtophat
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 695
+ -- Function File: B = imtophat (A, SE)
+ -- Function File: B = imtophat (A, SE, TYPE)
+ Perform morphological top hat filtering.
+
+ The image A must be a grayscale or binary image, and SE must be a
+ structuring element. Both must have the same class, e.g., if A is a
+ logical matrix, SE must also be logical.
+
+ TYPE defines the type of top hat transform. To perform a white, or
+ opening, top-hat transform its value must be `open' or `white'. To
+ perform a black, or closing, top-hat transform its value must be
+ `close' or `black'. If TYPE is not specified, it performs a white
+ top-hat transform.
+
+ See also: imerode, imdilate, imopen, imclose, 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
+imtranslate
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 273
+ -- 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
+iradon
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 2228
+ -- Function: 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: [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: 128
+ -- Function File: BOOL = isbw (BW)
+ Returns true for a black-white (binary) image. All values must be
+ either 0 or 1
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 46
+Returns true for a black-white (binary) image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 6
+isgray
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 277
+ -- Function File: BOOL = isgray (I)
+ Returns true for an gray-scale intensity image. An variable is a
+ gray scale image if it is 2-dimensional matrix, and
+ * is of class double and all values are in the range [0, 1], or
+
+ * is of class uint8 or uint16.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 47
+Returns true for an gray-scale intensity image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+isind
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 148
+ -- Function File: BOOL = isind (X)
+ Returns true for an index image. All index values must be
+ intergers and greater than or equal to 1.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 32
+Returns true for an index image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+isrgb
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 607
+ -- Function File: FLAG = isrgb (A)
+ Returns true if parameter is a RGB image.
+
+ `flag=isrgb(A)' returns 1 if A is a RGB image and 0 if not.
+
+ To the decide `isrgb' uses the follow algorithm:
+ * If A is of class double then it checks if all values are
+ between 0 and 1, and if size is m-by-n-by-3.
+
+ * If A is of class uint16, uint8 or logical then it checks is
+ m-by-n-by-3.
+
+ *Compatibility notes:*
+
+ Information needed on whether MATLAB accepts logical arrays as RGB
+ images (now this functions accepts them if they are m-by-n-by-3
+ arrays.
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 41
+Returns true if parameter is a RGB image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 9
+label2rgb
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1740
+ -- Function File: RGB = label2rgb(L)
+ -- Function File: RGB = label2rgb(L, MAP)
+ -- Function File: RGB = label2rgb(L, MAP, BACKGROUND)
+ -- Function File: RGB = label2rgb(L, MAP, BACKGROUND, ORDER)
+ Converts a labeled image to an RGB image.
+
+ label2rgb(L) returns a color image, where the background color
+ (the background is the zero-labeled pixels) is white, and all other
+ colors come from the `jet' colormap.
+
+ label2rgb(L, MAP) uses colors from the given colormap. MAP can be
+ * A string containing the name of a function to be called to
+ produce a colormap. The default value is "jet".
+
+ * A handle to a function to be called to produce a colormap.
+
+ * A N-by-3 colormap matrix.
+
+ label2rgb(L, MAP, BACKGROUND) sets the background color.
+ BACKGROUND can be a 3-vector corresponding to the wanted RGB
+ color, or one of the following strings
+ `"b"'
+ The background color will be blue.
+
+ `"c"'
+ The background color will be cyan.
+
+ `"g"'
+ The background color will be green.
+
+ `"k"'
+ The background color will be black.
+
+ `"m"'
+ The background color will be magenta.
+
+ `"r"'
+ The background color will be red.
+
+ `"w"'
+ The background color will be white. This is the default
+ behavior.
+
+ `"y"'
+ The background color will be yellow.
+
+ label2rgb(L, MAP, BACKGROUND, ORDER) allows for random
+ permutations of the colormap. ORDER must be one of the following
+ strings
+ `"noshuffle"'
+ The colormap is not permuted in any ways. This is the default.
+
+ `"shuffle"'
+ The used colormap is permuted randomly.
+
+ See also: bwlabel, ind2rgb
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 41
+Converts a labeled image to an RGB image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+makelut
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 819
+ -- 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: 8
+mat2gray
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 92
+ -- Function File: I = mat2gray (M,[min max])
+ Converts a matrix to a intensity image.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 39
+Converts a matrix to a intensity image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 5
+mean2
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 141
+ -- Function File: M = mean2 (I)
+ Returns the mean value for a 2d real type matrix. Uses
+ `mean(I(:))'
+
+ See also: std2, mean
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 49
+Returns the mean value for a 2d real type matrix.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+medfilt2
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 533
+ -- Function File: medfilt2(A, [DOMAIN, PADDING])
+ Two dimensional median filtering.
+
+ Replaces elements of A with the median of their neighbours defined
+ by true elements of logical matrix DOMAIN. The default DOMAIN is a
+ 3 by 3 matrix with all elements equal to 1. If DOMAIN is 1 by 2
+ row vector, the domain matrix will be logical(ones(DOMAIN(2),
+ DOMAIN(1))).
+
+ Optional variable PADDING defines the padding used in augmenting
+ the borders of A. See impad for details.
+
+ See also: ordfilt2
+
+
+
+
+
+# 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: 598
+ -- Function File: GRAD = mmgradm(A, SE)
+ -- Function File: GRAD = mmgradm(A, SE_DIL, SE_ERO)
+ Calculates the morphological gradient GRAD of a given image A.
+
+ In the first form, the same structuring element SE is used for
+ dilation and erosion. In the second form, SE_DIL and SE_ERO are the
+ corresponding structuring elements used for dilation and erosion
+
+ The image A must be a grayscale or a binary image.
+
+ The morphological gradient of a image corresponds to its erosion
+ subtracted to its dilation.
+
+ See also: imerode, imdilate, imopen, imclose, imtophat
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 62
+Calculates the morphological gradient GRAD of a given image A.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+nlfilter
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1004
+ -- Function File: B = nlfilter (A, [M,N], FUN)
+ -- Function File: B = nlfilter (A, [M,N], FUN, ...)
+ -- Function File: B = nlfilter (A,'indexed', ...)
+ Processes image in sliding blocks using user-supplied function.
+
+ `B=nlfilter(A,[m,n],fun)' passes sliding M-by-N blocks to
+ user-supplied function FUN. A block is build for every pixel in A,
+ such as it is centered within the block. FUN must return a
+ scalar, and it is used to create matrix B. NLFILTER pads the
+ M-by-N block at the edges if necessary.
+
+ Center of block is taken at ceil([M,N]/2).
+
+ `B=nlfilter(A,[m,n],fun,...)' behaves as described above but
+ passes extra parameters to function FUN.
+
+ `B=nlfilter(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, blkproc, inline
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 63
+Processes image in sliding blocks using user-supplied function.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+ordfilt2
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 690
+ -- Function File: ordfilt2(A, NTH, DOMAIN, [S, PADDING])
+ Two dimensional ordered filtering.
+
+ Ordered filter replaces an element of A with the NTH 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 impad for details.
+
+ See also: medfilt2
+
+
+
+
+
+# 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: 705
+ -- Function File: ordfiltn(A, NTH, DOMAIN, [S, PADDING])
+ Two dimensional ordered filtering.
+
+ Ordered filter replaces an element of A with the NTH 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: ordfilt2, padarray
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 34
+Two dimensional ordered filtering.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 8
+padarray
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1878
+ -- Function File: B = padarray (A,PADSIZE)
+ -- Function File: B = padarray (A,PADSIZE,PADVAL)
+ -- Function File: B = padarray (A,PADSIZE,PADVAL,DIRECTION)
+ Pads an array in a configurable way.
+
+ B = padarray(A,padsize) pads an array A with zeros, where PADSIZE
+ defines the amount of padding to add in each dimension (it must be
+ a vector of positive integers).
+
+ Each component of PADSIZE defines the number of elements of
+ padding that will be added in the corresponding dimension. For
+ instance, [4,5] adds 4 elements of padding in first dimension
+ (vertical) and 5 in second dimension (horizontal).
+
+ B = padarray(A,padsize,padval) pads A using the value specified by
+ PADVAL. PADVAL can be a scalar or a string. Possible values are:
+
+ 0
+ Pads with 0 as described above. This is the default behaviour.
+
+ Scalar
+ Pads using PADVAL as a padding value.
+
+ "Circular"
+ Pads with a circular repetition of elements in A (similar to
+ tiling A).
+
+ "Replicate"
+ Pads replicating values of A which are at the border of the
+ array.
+
+ "Symmetric"
+ Pads with a mirror reflection of A.
+
+ "Reflect"
+ Same as "symmetric", but the borders are not used in the
+ padding.
+
+ B = padarray(A,padsize,padval,direction) pads A defining the
+ direction of the pad. Possible values are:
+
+ "Both"
+ For each dimension it pads before the first element the number
+ of elements defined by PADSIZE and the same number again after
+ the last element. This is the default value.
+
+ "Pre"
+ For each dimension it pads before the first element the
+ number of elements defined by PADSIZE.
+
+ "Post"
+ For each dimension it pads after the last element the number
+ of elements defined by PADSIZE.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 36
+Pads an array in a configurable way.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+phantom
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 2255
+ -- Function: P = phantom ('Shepp-Logan', N)
+ Produces the Shepp-Logan phantom, with size N x N. If N is
+ omitted, 256 is used.
+
+ -- Function: P = phantom ('Modified Shepp-Logan', N)
+ Produces a modified version of the Shepp-Logan phantom which has
+ higher contrast than the original, with size N x N. If N is
+ omitted, 256 is used.
+
+ -- Function: P = phantom (ELLIPSES, N)
+ Produces a custom phantom using the ellipses described in ELLIPSES.
+ Each row of ELLIPSES describes one ellipse, and must have 6
+ columns: {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 vercal 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. If N is omitted, 256 is used.
+
+ -- Function: P = phantom (N)
+ Creates a modified Shepp-Logan phantom with size N x N.
+
+ -- Function: P = phantom ()
+ Creates a modified Shepp-Logan phantom with size 256 x 256.
+
+ Create a Shepp-Logan or modified Shepp-Logan phantom.
+
+ 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 ellipses. This allows rigorous testing of computed tomography
+(CT) algorithms as it can be analytically transformed with the radon
+transform (see the function `radon').
+
+ Example:
+
+ P = phantom (512);
+ imshow (P, []);
+
+ References:
+
+ Shepp, L. A.; Logan, B. F.; Reconstructing Interior Head Tissue
+from X-Ray Transmissions, IEEE Transactions on Nuclear Science, Feb.
+1974, p. 232.
+
+ Toft, P.; "The Radon Transform - Theory and Implementation", Ph.D.
+thesis, Department of Mathematical Modelling, Technical University of
+Denmark, June 1996.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 50
+Produces the Shepp-Logan phantom, with size N x N.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 9
+poly2mask
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 1182
+ -- 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: 2390
+ -- 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: 904
+ -- 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: 412
+ -- 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: 346
+ -- 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: 865
+ -- 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: 672
+ -- 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: 2719
+ -- Function File: PROPS = regionprops (BW)
+ -- Function File: PROPS = regionprops (BW, 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 following properties can be computed.
+
+ "Area"
+ The number of pixels in the object.
+
+ "EulerNumber"
+ "euler_number"
+ The Euler number of the object (see `bweuler' for details).
+
+ "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.
+
+ "Extent"
+ The area of the object divided by the area of the bounding
+ box.
+
+ "Perimeter"
+ The length of the boundary of the object.
+
+ "Centroid"
+ The center coordinate of the object.
+
+ "PixelIdxList"
+ "pixel_idx_list"
+ The indices of the pixels in the object.
+
+ "FilledArea"
+ "filled_area"
+ The area of the object including possible holes.
+
+ "PixelList"
+ "pixel_list"
+ The actual pixel values inside the object. This is only
+ useful for grey scale images.
+
+ "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.
+
+ "MinIntensity"
+ "min_intensity"
+ The minimum intensity inside the object.
+
+ "WeightedCentroid"
+ "weighted_centroid"
+ The centroid of the object where pixel values are used as
+ weights.
+
+ "MeanIntensity"
+ "mean_intensity"
+ The mean intensity inside the object.
+
+ "PixelValues"
+ "pixel_values"
+ The pixel values inside the object represented as a vector.
+
+ 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".
+
+ "all"
+ All properties are computed.
+
+ If no properties are given, basic is assumed.
+
+ 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: 415
+ -- Function File: GRAY = rgb2gray (RGB)
+ Converts an RGB image to a gray scale image, or a color map to a
+ gray map.
+
+ If the input is an RGB image, the conversion to a gray image is
+ computed as the mean value of the color channels.
+
+ If the input is a color map it is converted into the YIQ space of
+ ntsc. The luminance value (Y) is taken to create a gray color map.
+ R = G = B = Y
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 74
+Converts an RGB image to a gray scale image, or a color map to a gray
+map.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 9
+rgb2ycbcr
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 398
+ -- Function File: B = rgb2ycbcr(A)
+ Perform colour convertion from RGB to YCbCr on a given image.
+
+ The image A must be a NxMx3 image. The conversion The convertion
+ changes the image from the RGB color model to YCbCr e.g.
+ imOut = rgb2ycbcr(imIn);
+ Currently this function only works with `uint8' and will always
+ return an `uint8' matrix.
+
+ See also: cmunique
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 61
+Perform colour convertion from RGB to YCbCr on a given image.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+rgbplot
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 316
+ -- Function File: rgbplot (MAP)
+ -- Function File: H = rgbplot (MAP)
+ Plot a given color map. The matrix MAP must be a M by 3 matrix.
+ The three columns of the colormap matrix are plotted in red,
+ green, and blue lines.
+
+ If an output is requested, a graphics handle to the plot is
+ returned.
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 23
+Plot a given color map.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 10
+rho_filter
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 2383
+ -- Function: 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: [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: 148
+ -- 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: 1069
+ -- 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: 1940
+ -- 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: 42
+Finds limits to contrast stretch an image
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 13
+tiff_tag_read
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 441
+ -- Function File: [ VALUE, OFFSET] = tiff_tag_read (FILE, TAG, IFD)
+ Reads the values of TIFF file tags.
+
+ FILE is a TIFF file and TAG is the tag number to read. If IFD is
+ given, only the tag value from that IFD (Image File Directory)
+ will be read. By default, reads only the first IFD.
+
+ VALUE is the read value from TAG. OFFSET will be `1' if VALUE is a
+ file offset.
+
+ See also: imread, imfinfo, readexif
+
+
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 35
+Reads the values of TIFF file tags.
+
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 7
+uintlut
+
+
+# name: <cell-element>
+# type: sq_string
+# elements: 1
+# length: 250
+ -- Function File: B = uintlut (A,LUT)
+ Computes matrix B by using A as an index to lookup table LUT.
+
+ 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.
+
+
+
+
+
git://git.creatis.insa-lyon.fr / CreaPhase.git / blobdiff