# ToolBag file level help

## C:\Users\AB\DArT_Toolshed\ToolBag\AlgPicker

AlgPicker.m

Hanna, 2005

DArT_Toolshed_Contents.m

## C:\Users\AB\DArT_Toolshed\ToolBag\Demo of JRK GUI

GuiDemo.m

## C:\Users\AB\DArT_Toolshed\ToolBag\FEMGrowthTool

FEMGrowthTool.m

function FEMGrowthTool(varargin) Examples: FEMGrowthTool; FEMGrowthTool('growth_filename', 'Data/a.mat'); Dr. A. I. Hanna (2007)

## C:\Users\AB\DArT_Toolshed\ToolBag\FEMViewer

FEMViewer.m

function FEMViewer(varargin) A very simple FEM visualization tool. Dr. A. I. Hanna CMP, UEA, 2006.

test_femlib.m

## C:\Users\AB\DArT_Toolshed\ToolBag\ImageCompositer

ImageCompositer.m

Hi! I am a simple image utility made for Sam Fox and her GFP/Confocal microscope images. I work with Matlab version 2007a but not 2007b as there seems to be some compatibility issues (probably with roipoly+handles). I was created initially using GUIDE (as evidenced below) but unfortunately my creator had a 'falling-out' with GUIDE halfway through making me, are no longer on speaking terms and wrote some of me manually. As a result, I contain some ugly program code and should not be used as good example of working matlab. I also don't contain much error handling or code comments I am very sorry and feel ashamed but.. ...I DO work as I am supposed too!! Please don't hate me because I am ugly, as that is not nice... IMAGECOMPOSITER M-file for ImageCompositer.fig IMAGECOMPOSITER, by itself, creates a new IMAGECOMPOSITER or raises the existing singleton*. H = IMAGECOMPOSITER returns the handle to a new IMAGECOMPOSITER or the handle to the existing singleton*. IMAGECOMPOSITER('CALLBACK',hObject,eventData,handles,...) calls the local function named CALLBACK in IMAGECOMPOSITER.M with the given input arguments. IMAGECOMPOSITER('Property','Value',...) creates a new IMAGECOMPOSITER or raises the existing singleton*. Starting from the left, property value pairs are applied to the GUI before ImageCompositer_OpeningFcn gets called. An unrecognized property name or invalid value makes property application stop. All inputs are passed to ImageCompositer_OpeningFcn via varargin. *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one instance to run (singleton)". See also: GUIDE, GUIDATA, GUIHANDLES

imoverlay.m

IMOVERLAY Create a mask-based image overlay. OUT = IMOVERLAY(IN, MASK, COLOR) takes an input image, IN, and a binary image, MASK, and produces an output image whose pixels in the MASK locations have the specified COLOR. IN should be a grayscale or an RGB image of class uint8, uint16, int16, logical, double, or single. If IN is double or single, it should be in the range [0, 1]. If it is not in that range, you might want to use mat2gray to scale it into that range. MASK should be a two-dimensional logical matrix. COLOR should be a 1-by-3 vector of values in the range [0, 1]. [0 0 0] is black, and [1 1 1] is white. OUT is a uint8 RGB image. Examples -------- Overlay edge detection result in green over the original image. I = imread('cameraman.tif'); bw = edge(I, 'canny'); rgb = imoverlay(I, bw, [0 1 0]); imshow(rgb) Treating the output of peaks as an image, overlay the values greater than 7 in red. The output of peaks is not in the usual grayscale image range of [0, 1], so use mat2gray to scale it. I = peaks; mask = I > 7; rgb = imoverlay(mat2gray(I), mask, [1 0 0]); imshow(rgb, 'InitialMagnification', 'fit')

## C:\Users\AB\DArT_Toolshed\ToolBag\ImageReScaler

ImageReScaler.m

## C:\Users\AB\DArT_Toolshed\ToolBag\LeicaScript

LeciaScript.m

## C:\Users\AB\DArT_Toolshed\ToolBag\MakeTestShapes

MakeTestShapes.m

MakeTestShapesReadMeanShape.m

runMakeTestShapes.m

% project vars

## C:\Users\AB\DArT_Toolshed\ToolBag\ReactionDiffusionTool

## C:\Users\AB\DArT_Toolshed\ToolBag\ReactionDiffusionTool\AnisotropicReactionDiffusion

conditions.m

diffuse_chem.m

function chem = diffuse_chem(chem, diffRate, consumeRate, dt) So we can do this is several ways, we have chosen to take the convolution route. Recall that using del2 divides by 4, so we had better do the same to the convolution mask. The second reason for doing it this way is that we can plug in specific values to obtain anisotropic diffusion. Dr. A. I. Hanna (2006).

run_anisotropic_example.m

function run_anisotropic_example A simple script to show anisotropic reaction diffusion Needs to be put into a tool or toolbox but the methods are all here Dr. A. I. Hanna, CMP, 2008.

## C:\Users\AB\DArT_Toolshed\ToolBag\ReactionDiffusionTool\ParamFiles

ReactionDiffusionTool.m

function ReactionDiffusionTool A small application to simulate isotropic reaction-diffusion. Usage: ReactionDiffusionTool; Dr. A. I. Hanna, CMP, 2005

## C:\Users\AB\DArT_Toolshed\ToolBag\RecursivelyFindDependencies

deppkg.m

deppkg(SRC, DEST, IS_recursive) Input Parameters: SRC {str}(n) : Source m-file script/function to parse DEST {srt}(m) : Destination directory to copy dependencies to Function to find and consolidate all file dependencies for an m-file script/function or all such files in a given directory Anything that falls under the matlab root path will be ommitted (e.g. toolboxes, and standard functions). Jit Sarkar MPL/SIO 2011/04/20 Copy_List = deppkg(SRC,DEST) Output Parameters: Copy_List {cell}{str}(Nc) : IS_recursive is only used internally to trigger actual file copying, otherwise the recursion would copy your given SRC file(s) as well. Usage dependsOn=deppkg('GuiDemo.m','Dependencies'); % where GuiDemo is the m file being investigated and % where Dependencies is a local directory into which all the files on which % GuiDemo depends - they can then all be zipped together to produce a self % contained edifice.

myDepFun.m

Dep_List=myDepFun(name,toolbox) Tool for recursively finding what further functions a function depends on. myDepFun then creates a subdirectory of the 'toolbox' directory and copies all the 'external' functions that it finds into that directory. It also puts a copy of the full results (.mat file) into that subdirectory. WARNING: if the function depends on classfiles (in a directory with a name beginning with @) then please create a subdirectory within the directory 'toolbox' with the following form 'NAME_Dependencies_outside_TOOLBOX' and copy the classfile directories and contents directly into this new directory, e.g. AAMToolbox_Dependencies_outside_ShapeModelToolbox (This is because 'depfun' does not recognise classfile types.) name, name of function m file inside a toolbox (without the suffix) toolbox, path and name of the toolbox in which the function resides and which would normally be expected to contain all the functions needed. Functions outside the toolbox are 'external' tools all, default false and the final list excludes functions in the toolbox, if true then all functions are listed and external files are not copied into a local directory Dep_List, a list of all the external tools with their DArT_Toolshed paths Usage list=myDepFun('AAMToolbox','C:\DArT_Toolshed\Toolboxes\ShapeModelToolbox') WARNING at present this does not check each filename to see whether there is an associated compiled version, i.e. dll, mexx64 etc. To add a check would be straightforward if there is always an associated .m file J. Andrew Bangham, 2012

## C:\Users\AB\DArT_Toolshed\ToolBag\SelectOrderListDlg

SelectOrderListDlg.m

SelectOrderListDlg Ordered List selection dialog box. [SELECTION,OK] = SelectOrderListDlg('ListString',S) creates a modal dialog box which allows you to select a string or multiple strings from a list. SELECTION is a cell structure of the selected strings. Inputs are in parameter,value pairs: Parameter Description 'ListString' cell array of strings for the list box. A 'Select all' button is provided in the multiple selection case. Example: d = dir; str = {d.name}; [s,v] = SelectOrderListDlg('ListString',str); Dr. A. I. Hanna (2005) CMP, UEA, 2005.

## C:\Users\AB\DArT_Toolshed\ToolBag\ShapeEdgeEditor

ShapeEdgeEditor.m

function ShapeEdgeEditor(varargin) Example 1: edges = ShapeEdgeEditor; Example 2: theta = linspace(0, 2*pi, 20); x = cos(theta); y = sin(theta); edges = ShapeEdgeEditor('pts', [x(:), y(:)]); Dr. A. I. Hanna (2005) CMP, UEA, 2005.

## C:\Users\AB\DArT_Toolshed\ToolBag\SieveStack

sieveStack.m

## C:\Users\AB\DArT_Toolshed\ToolBag\SpatialAnnotation

AnnotateImage.m

GaussianFilter3D.m

function imout=GaussianFilter3D(imin,sigma) using 3 x 1D convolutions (or 2 x 1D for 2D image) NOTE: it pads with 0's at the boundaries imin, 2D or 3D volume input sigma, standard deviation of filter required (larger is slower, don't go above say 10) verbose, true to plot out results imout, output volume the same size as imin J.Andrew Bangham 2010 Usage GaussianFilter3D; % sigma=5. Generate an impulse response image volume and display progress im=GaussianFilter3D(im,2,false); % will replace 3D im by a volume filtered by Gaussian sigma=2

LoadMSR.m

function MSR=LoadMSR(filename,fieldgroups) filename, .msr file containing the data requestedfields, required fields {'field1','field2',...} hearder fields such as 'msr_version', MSR.objects.objectname' are included by default removeemptyfields, [true,false] default to true: remove empty fields J.Andrew Bangham, 2010

MakeIsoSurface.m

function MakeIsoSurface(args,opt) cd into the AAMToolbox project directory MakeIsoSurface('initialise',704LerNo24HASH1L1_x0p84y0p84z0p80conf'); MakeIsoSurface('initialise','ASN003_x0p61y0p61z0p86conf'); J.Andrew Bangham, 2010

ReadMSR2.m

ReadMSR2B.m

ReadSlices.m

WriteSlices.m

function WriteSlices(pathDirectory,VolumeImage,type,VolumeImageitdepth) pathDirectory,directory into which slices are to be written VolumeImage, either [x,y,[1:3],z] colour images with z slices or [x,y,z] grayscale images with z slices type, default png ('png' 'jpg') VolumeImageitdepth, default 8

gong.m

gong: sounds gong by John Gooden - The Netherlands 2007 call gong call gong(vol) call gong(vol,frq) call gong(vol,frq,dur) input arguments (optional, if 0 then default taken) vol = volume (default = 1) frq = base frequency (default = 440 Hz) dur = duration (default = 1 s)

load3D.m

function isos3=load3D(name) loads a 3D image from its slices and fits an isosurface J. Andrew Bangham, 2010;

msrread_jab.m

MSRREAD Read a MSR file (see wiki MSR_File_Specification for definition) The first argument is the filename, the return is a structure containing a transcription of the file content. Fields of the structure returned: 'version' -> String containing the version of the file 'original_filename' -> Path to the directory or file containing the original data 'scale' -> 3x1 vector (sx, sy, sz) with the scale of each component in the file (i.e. size of a voxel). After that, all coordinates are expressed in voxel. 'time' -> Time (in hours) ellapsed since some reference. Cannot exist if 'date' is present. 'date' -> [year month day hour min sec] time at which the data was acquired (timing the sample). Cannot exist if 'time' is present. 'nb_objects' -> Number of objects defined in the measure file 'objects' -> Structure in which each field correspond to an object in the file Fields defining an object: 'name' -> Name of the object (same as the name of the field in objects. 'render_type' -> Rendering type for the object. i.e. how it should be rendered. 'vertices' -> Nx3 array if the object has N vertices. Columns correspond to x,y,z 'edges' -> Ex2 array of integers for E edges. Columns are source and target of the edge. 'edges_shape' -> Ex1 structure with these fields: 'type' -> Defines how the edge shape is defined. 'spec' -> Specification of the shape, if needed. For type=POLYLINE spec is a nx3 array with each line being a point defining the polyline. Start and end points are not specified as they are the vertices of the edge. 'edges_growth' -> Structure with one element per growth interval. 'dt' -> Interval for which this growth is computed 'growth_rates' -> Ex1 array with the linear growth rate of each edge 'faces' -> Fx1 cell array for F faces. Each cell contains the list of vertices defining the face. 'faces_normal' -> Fx3 array with the columns begin Nx, Ny and Nz, the coordinates of the normal of the face. 'faces_growth' -> Structure with one element per growth interval. 'dt' -> Interval for which this growth is computed 'growth_tensors' -> Fx5 array with the strain tensor of the face. The columns are kmax, kmin, vx, vy and vz. (vx,vy,vz) is the unit vector defining the direction of maximum growth of the face.

msrwrite_jab.m

MSRWRITE Write a MSR file (see wiki MSR_File_Specification for definition) The first argument is the filename, the second is a structure defining the MSR file. Any fields not defined below will be ignored. Fields of the MSR structure: 'originalfilename' -> Path to the directory or file containing the original data 'scale' -> 3x1 vector (sx, sy, sz) with the scale of each component in the file (i.e. size of a voxel). After that, all coordinates are expressed in voxel. 'time' -> Time (in hours) ellapsed since some reference. Cannot exist if 'date' is present. 'date' -> [year month day hour min sec] time at which the data was acquired (timing the sample). Cannot exist if 'time' is present. 'objectcount' -> Number of objects defined in the measure file 'objects' -> Structure in which each field correspond to an object in the file Fields defining an object: 'name' -> Name of the object (must be the same as the name of the field in objects). If not specified, the name in the objects field is used. 'rendertype' -> Rendering type for the object. i.e. how it should be rendered. 'vert' -> Nx3 array if the object has N vert. Columns correspond to x,y,z 'edges' -> Ex2 array of integers for E edges. Columns are source and target of the edge. 'edgeshape' -> Ex1 structure with these fields: 'type' -> Defines how the edge shape is defined. 'spec' -> Specification of the shape, if needed. For type=POLYLINE spec is a nx3 array with each line being a point defining the polyline. Start and end points are not specified as they are the vert of the edge. 'edgegrowth' -> Structure with one element per growth interval. 'dt' -> Interval for which this growth is computed 'growth_rates' -> Ex1 array with the linear growth rate of each edge 'faces' -> Fx1 cell array for F faces. Each cell contains the list of vert defining the face. 'facenormal' -> Fx3 array with the columns begin Nx, Ny and Nz, the coordinates of the normal of the face. 'facegrowth' -> Structure with one element per growth interval. 'dt' -> Interval for which this growth is computed 'growth_tensors' -> Fx5 array with the strain tensor of the face. The columns are kmax, kmin, vx, vy and vz. (vx,vy,vz) is the unit vector defining the direction of maximum growth of the face.

objdiff.m

OBJDIFF compares two objects & returns an object of the same type with just the different fields/values. OBJDIFF (unlike Matlab's SETDIFF or SETXOR) also compares structs, GUI handles, ActiveX, Matlab & Java objects, in addition to arrays & cells. OBJDIFF also allows comparison of numeric cell arrays, unlike SETDIFF/ SETXOR. It also accepts everything that SETDIFF/SETXOR accept. Syntax: [objectC,IA,IB] = objdiff (objectA, objectB, options, ...) Inputs: objectA - first object to compare objectB - second object to compare. Field order in opaque objects does not matter. Note: If objectB is not supplied, then objectA(1) is compared to objectA(2) options - optional flags as follows: 'rows' - see documentation for <a href="matlab:doc setxor">SETXOR</a> 'dontIgnoreJava' - show different instances of the same java class (default=ignore them) Outputs: objectC - object containing only the different (or new) fields, in a {old, new} pattern IA,IB - index vector into objectA,objectB such that objectC = [objectA(IA),objectB(IB)] (see SETXOR) Examples: >> objectA = struct('a',3, 'b',5, 'd',9); >> objectB = struct('a','ert', 'c',struct('t',pi), 'd',9); >> objectC = objdiff(objectA, objectB) % a=different, b=new in objectA, c=new in objectB, d=same objectC = a: {[3] 'ert'} b: {[5] {}} c: {{} [1x1 struct]} >> objectC = objdiff(java.awt.Color.red, java.awt.Color.blue) objectC = Blue: {[0] [255]} RGB: {[-65536] [-16776961]} Red: {[255] [0]} >> objectC = objdiff(0,gcf) % 0 is the root handle objectC = children: {[2x1 struct] []} handle: {[0] [1]} properties: {[1x1 struct] [1x1 struct]} type: {'root' 'figure'} >> [objectC,IA,IB] = objdiff({2,3,4,7}, {2,4,5}) objectC = 3 5 7 IA = 2 4 IB = 3 Bugs and suggestions: Please send to Yair Altman (altmany at gmail dot com) Change log: 2007-07-27: Fixed handling of identical objects per D. Gamble 2007-03-23: First version posted on <a href="http://www.mathworks.com/matlabcentral/fileexchange/loadAuthor.do?objectType=author&mfx=1&objectId=1096533#">MathWorks File Exchange</a> See also: SETDIFF, SETXOR, ISSTRUCT, ISJAVA, ISHGHANDLE, ISOBJECT, ISCELL

select3d.m

SELECT3D(H) Determines the selected point in 3-D data space. P = SELECT3D determines the point, P, in data space corresponding to the current selection position. P is a point on the first patch or surface face intersected along the selection ray. If no face is encountered along the selection ray, P returns empty. P = SELECT3D(H) constrains selection to graphics handle H and, if applicable, any of its children. H can be a figure, axes, patch, or surface object. [P V] = SELECT3D(...), V is the closest face or line vertex selected based on the figure's current object. [P V VI] = SELECT3D(...), VI is the index into the object's x,y,zdata properties corresponding to V, the closest face vertex selected. [P V VI FACEV] = SELECT3D(...), FACE is an array of vertices corresponding to the face polygon containing P and V. [P V VI FACEV FACEI] = SELECT3D(...), FACEI is the row index into the object's face array corresponding to FACE. For patch objects, the face array can be obtained by doing get(mypatch,'faces'). For surface objects, the face array can be obtained from the output of SURF2PATCH (see SURF2PATCH for more information). RESTRICTIONS: SELECT3D supports surface, patch, or line object primitives. For surface and patches, the algorithm assumes non-self-intersecting planar faces. For line objects, the algorithm always returns P as empty, and V will be the closest vertex relative to the selection point. Example: h = surf(peaks); zoom(10); disp('Click anywhere on the surface, then hit return') pause [p v vi face facei] = select3d; marker1 = line('xdata',p(1),'ydata',p(2),'zdata',p(3),'marker','o',... 'erasemode','xor','markerfacecolor','k'); marker2 = line('xdata',v(1),'ydata',v(2),'zdata',v(3),'marker','o',... 'erasemode','xor','markerfacecolor','k'); marker2 = line('erasemode','xor','xdata',face(1,:),'ydata',face(2,:),... 'zdata',face(3,:),'linewidth',10); disp(sprintf('\nYou clicked at\nX: %.2f\nY: %.2f\nZ: %.2f',p(1),p(2),p(3)')) disp(sprintf('\nThe nearest vertex is\nX: %.2f\nY: %.2f\nZ: %.2f',v(1),v(2),v(3)')) Version 1.3 11-11-04 Copyright Joe Conti 2004 Send comments to jconti@mathworks.com See also GINPUT, GCO.

tellVolViewer.m

function tellVolViewer(foldername) Pass commands to VolViewer which is running in the background on a different thread. VolViewer must be launched with instructions showing where to find the Watchme.txt file commands will be stored in foldername that is named in Watchme.txt J. Andrew Bangham, 2010

viewsieve3D.m

function YY=Viewsieve3D(pathname,filename,minvol,WatchDirectory,verbose) Use the 3D sieve to segment out a large volume object from background pathname, path to filename filename, name of directory containing stack of images minvol, the minimum volume of extrema preserved by the 3D sieve can be set to empty [] in which case the default will be estimated by analysing the image WatchDirectory, the temporary directory used to store image stack for VolViewer Verbose, default true - displays result in VolViewer which must be running separately YY, resulting uint8 volume image (also stored as an image stack in the WatchDirectory Usage Viewsieve3D(pathname,filename); J. Andrew Bangham, 2010

## C:\Users\AB\DArT_Toolshed\ToolBag\StackViewer

StackViewer.m

function StackViewer(varargin) Opens and displays stacks generated by ImageJ. The stack must be in TIF format. Dr. A. I. Hanna, CMP, UEA, 2007.

## C:\Users\AB\DArT_Toolshed\ToolBag\Usefull

arrow.m

ARROW Draw a line with an arrowhead. ARROW(Start,Stop) draws a line with an arrow from Start to Stop (points should be vectors of length 2 or 3, or matrices with 2 or 3 columns), and returns the graphics handle of the arrow(s). ARROW uses the mouse (click-drag) to create an arrow. ARROW DEMO & ARROW DEMO2 show 3-D & 2-D demos of the capabilities of ARROW. ARROW may be called with a normal argument list or a property-based list. ARROW(Start,Stop,Length,BaseAngle,TipAngle,Width,Page,CrossDir) is the full normal argument list, where all but the Start and Stop points are optional. If you need to specify a later argument (e.g., Page) but want default values of earlier ones (e.g., TipAngle), pass an empty matrix for the earlier ones (e.g., TipAngle=[]). ARROW('Property1',PropVal1,'Property2',PropVal2,...) creates arrows with the given properties, using default values for any unspecified or given as 'default' or NaN. Some properties used for line and patch objects are used in a modified fashion, others are passed directly to LINE, PATCH, or SET. For a detailed properties explanation, call ARROW PROPERTIES. Start The starting points. B Stop The end points. /|\ ^ Length Length of the arrowhead in pixels. /|||\ | BaseAngle Base angle in degrees (ADE). //|||\\ L| TipAngle Tip angle in degrees (ABC). ///|||\\\ e| Width Width of the base in pixels. ////|||\\\\ n| Page Use hardcopy proportions. /////|D|\\\\\ g| CrossDir Vector || to arrowhead plane. //// ||| \\\\ t| NormalDir Vector out of arrowhead plane. /// ||| \\\ h| Ends Which end has an arrowhead. //<----->|| \\ | ObjectHandles Vector of handles to update. / base ||| \ V E angle||<-------->C ARROW(H,'Prop1',PropVal1,...), where H is a |||tipangle vector of handles to previously-created arrows ||| and/or line objects, will update the previously- ||| created arrows according to the current view -->|A|<-- width and any specified properties, and will convert two-point line objects to corresponding arrows. ARROW(H) will update the arrows if the current view has changed. Root, figure, or axes handles included in H are replaced by all descendant Arrow objects. A property list can follow any specified normal argument list, e.g., ARROW([1 2 3],[0 0 0],36,'BaseAngle',60) creates an arrow from (1,2,3) to the origin, with an arrowhead of length 36 pixels and 60-degree base angle. The basic arguments or properties can generally be vectorized to create multiple arrows with the same call. This is done by passing a property with one row per arrow, or, if all arrows are to have the same property value, just one row may be specified. You may want to execute AXIS(AXIS) before calling ARROW so it doesn't change the axes on you; ARROW determines the sizes of arrow components BEFORE the arrow is plotted, so if ARROW changes axis limits, arrows may be malformed. This version of ARROW uses features of MATLAB 6.x and is incompatible with earlier MATLAB versions (ARROW for MATLAB 4.2c is available separately); some problems with perspective plots still exist.

toolSLOC.m

function [total,sloc,chars]=toolSLOC(name) count the total Source Lines Of Code (a measure of programming effort) name, the name of a directory containing a Matlab project total, total of matlab, c, c++ and python lines of code sloc.m the total number of Matlab code (.m file) lines in .m files within the directory It recurses through all subdirectories. sloc.c total of c and c++ sloc.p total of py J. Andrew Bangham, 2011

## C:\Users\AB\DArT_Toolshed\ToolBag\VolViewerAPI

## C:\Users\AB\DArT_Toolshed\ToolBag\VolViewerAPI\CLASSFILES

## C:\Users\AB\DArT_Toolshed\ToolBag\VolViewerAPI\CLASSFILES\@VolViewer

MSRshowVOL.m

--- help for VolViewer/MSRshowVOL ---

function VOL=MSRshowVOL(VOL,MSR) use VolViewer to plot (or delete) 3D data from an MSR (shape outline) results file it saves the MSR data to a temporary file 'Temp.msr' in fullfile(VOL.PathToWatchFile,'TempVolViewerData') VOL, VolViewer object MSR, the shape information (default - select an .msr file if MSR == 1 (i.e. a scalar) then any existing MSR plot is deleted AxesH, handle to the axis in which it will be plotted J. Andrew Bangham, 2012

SelectAndShowStack.m

VolViewer.m

function VO=VolViewer(handshakeHandle,WatchFileNumber,PathToVolViewer,PathToWatchFile) VolViewer object constructor VO, a VolViewer object handshakeHandle, handle to object the colour of which will signal correct operation of VolViewer WatchFileNumber, if 0 (default) then VolViewer is not launched 1 VolViewer is launched with WatchFile1.txt 2 ... WatchFile2.txt PathToVolViewer, default is either C:\Program Files\VolViewer or the PathToVolViewer used in the previous VolViewer object (saved data file is in CLASSFILES directory containing @VolViewer) PathToWatchFile, default is either pwd (present working directory) or the PathToWatchFile used in the previous VolViewer object (saved data file is in CLASSFILES directory containing @VolViewer) It is assumed that PathTo is the path to the following files imageFiles: msrFilename: tfnFilename: slcFilename: vvrFilename: objFilename: Usage VOL=VolViewer; % create an object without launching VolViewer VOL=VolViewer(1); % create an object and launch VolViewer J.Andrew Bangham, 2012

commandsVOL.m

--- help for VolViewer/commandsVOL ---

[VOL,SoftError]=commandsVOL(VOL,varargin) Sends commands to VolViewer by writing them into the WatchFile Usage VOL=commandsVOL(VOL,'set_channels(0, 0, 0)'); J.Andrew Bangham 2012

display.m

DISPLAY Display array. DISPLAY(X) is called for the object X when the semicolon is not used to terminate a statement. For example, X = inline('sin(x)') calls DISPLAY(X) while X = inline('sin(x)'); does not. A typical implementation of DISPLAY calls DISP to do most of the work and looks as follows. Note that DISP does not display empty arrays. function display(X) if isequal(get(0,'FormatSpacing'),'compact') disp([inputname(1) ' =']); disp(X); else disp(' '); disp([inputname(1) ' =']); disp(' '); disp(X); end See also INPUTNAME, DISP, EVALC.

Overloaded methods: opaque/display sfit/display tree/display PointModelTemplate/display AAM_Element/display AAM/display avifile/display VideoReader/display cdfepoch/display inline/display timer/display serial/display ftp/display tscollection/display timeseries/display SimTimeseries/display phytree/display zpk/display tf/display ss/display realp/display pidstd/display pid/display loopswitch/display genss/display genmat/display genfrd/display daqdevice/display daqchild/display distributed/display codistributor2dbc/display codistributor1d/display codistributed/display gpuArray/display qfft/display vdspdebug/display eclipseide/display ccsrtdx/display ccsdebug/display imaqdevice/display imaqchild/display iviconfigurationstore/display icgroup/display instrument/display network/display frd/display cvtest/display cvdata/display dataset/display categorical/display vrworld/display vrnode/display vrfigure/display piecewisedistribution/display gmdistribution/display classregtree/display ProbDist/display NaiveBayes/display sym/display

Reference page in Help browser doc display

get.m

GET Get object properties. V = GET(H,'PropertyName') returns the value of the specified property for the graphics object with handle H. If H is a vector of handles, then get will return an M-by-1 cell array of values where M is equal to length(H). If 'PropertyName' is replaced by a 1-by-N or N-by-1 cell array of strings containing property names, then GET will return an M-by-N cell array of values. GET(H) displays all property names and their current values for the graphics object with handle H. V = GET(H) where H is a scalar, returns a structure where each field name is the name of a property of H and each field contains the value of that property. V = GET(0, 'Factory') V = GET(0, 'Factory<ObjectType>') V = GET(0, 'Factory<ObjectType><PropertyName>') returns for all object types the factory values of all properties which have user-settable default values. V = GET(H, 'Default') V = GET(H, 'Default<ObjectType>') V = GET(H, 'Default<ObjectType><PropertyName>') returns information about default property values (H must be scalar). 'Default' returns a list of all default property values currently set on H. 'Default<ObjectType>' returns only the defaults for properties of <ObjectType> set on H. 'Default<ObjectType><PropertyName>' returns the default value for the specific property, by searching the defaults set on H and its ancestors, until that default is found. If no default value for this property has been set on H or any ancestor of H up through the root, then the factory value for that property is returned. Defaults can not be queried on a descendant of the object, or on the object itself - for example, a value for 'DefaultAxesColor' can not be queried on an axes or an axes child, but can be queried on a figure or on the root. When using the 'Factory' or 'Default' GET, if PropertyName is omitted then the return value will take the form of a structure in which each field name is a property name and the corresponding value is the value of that property. If PropertyName is specified then a matrix or string value will be returned. See also SET, RESET, DELETE, GCF, GCA, FIGURE, AXES.

Overloaded methods: tree/get VolViewer/get PointModelTemplate/get AAM_Element/get AAM/get avifile/get scribehgobj/get scribehandle/get hgbin/get framerect/get figobj/get celltext/get cellline/get axistext/get axisobj/get axischild/get arrowline/get timer/get serial/get hgsetget/get RandStream/get COM/get tscollection/get timeseries/get phytree/get daqdevice/get daqchild/get qfft/get imaqdevice/get imaqchild/get iviconfigurationstore/get icgroup/get icdevice/get instrument/get InputOutputModel/get opcond.get dataset/get fdspec/get fdmeas/get fdline/get fdax/get vrworld/get vrnode/get vrfigure/get

Reference page in Help browser doc get

handshakeVOL.m

--- help for VolViewer/handshakeVOL ---

Reply=handshakeVOL(VOL,timeout) Sends commands 'string' to VolViewer by writing it into the WatchFile then waits for VolViewer to echo 'string' back in another file: WatchMeFile.txt VOL, a VolViewer object timeout, the length of time the function will wait for VolViewer to complete its task default is set by VOL.timeout, i.e. 30 secs. if timeout==0 then the function will not wait - it just returns with Reply=0 else timeout should be set to, say, 10 seconds (Default 30 secs) reply, if VolViewer has not replied within the specified time, Reply=false elseif VolViewer has replied, Reply=true; message, if VolViewer has not replied within the specified time, reply=timeout else message=string Usage [reply,message]=handshakeVOL(VOL); if ~handshakeVOL(VOL,10) error('VolViewer has not replied within 10 secs') end J.Andrew Bangham 2012

imshowVOL.m

--- help for VolViewer/imshowVOL ---

VOL=imshowVOL(VOL,stackDirectoryOrImageOrImage) VOL, VolViewer object stackDirectoryOrImage, either the full path to stacks OR a volume image [rows, cols, slice] J.Andrew Bangham, 2012

set.m

SET Set object properties. SET(H,'PropertyName',PropertyValue) sets the value of the specified property for the graphics object with handle H. H can be a vector of handles, in which case SET sets the properties' values for all the objects. SET(H,a) where a is a structure whose field names are object property names, sets the properties named in each field name with the values contained in the structure. SET(H,pn,pv) sets the named properties specified in the cell array of strings pn to the corresponding values in the cell array pv for all objects specified in H. The cell array pn must be 1-by-N, but the cell array pv can be M-by-N where M is equal to length(H) so that each object will be updated with a different set of values for the list of property names contained in pn. SET(H,'PropertyName1',PropertyValue1,'PropertyName2',PropertyValue2,...) sets multiple property values with a single statement. Note that it is permissible to use property/value string pairs, structures, and property/value cell array pairs in the same call to SET. A = SET(H, 'PropertyName') SET(H,'PropertyName') returns or displays the possible values for the specified property of the object with handle H. The returned array is a cell array of possible value strings or an empty cell array if the property does not have a finite set of possible string values. A = SET(H) SET(H) returns or displays all property names and their possible values for the object with handle H. The return value is a structure whose field names are the property names of H, and whose values are cell arrays of possible property values or empty cell arrays. The default value for an object property can be set on any of an object's ancestors by setting the PropertyName formed by concatenating the string 'Default', the object type, and the property name. For example, to set the default color of text objects to red in the current figure window: set(gcf,'DefaultTextColor','red') Defaults can not be set on a descendant of the object, or on the object itself - for example, a value for 'DefaultAxesColor' can not be set on an axes or an axes child, but can be set on a figure or on the root. Three strings have special meaning for PropertyValues: 'default' - use default value (from nearest ancestor) 'factory' - use factory default value 'remove' - remove default value. See also GET, RESET, DELETE, GCF, GCA, FIGURE, AXES.

Overloaded methods: BioSeq/set BioRead/set BioMap/set tree/set VolViewer/set PointModelTemplate/set AAM_Element/set AAM/set avifile/set scribehgobj/set scribehandle/set framerect/set figobj/set editrect/set editline/set celltext/set cellline/set axistext/set axisobj/set axischild/set arrowline/set timer/set serial/set hgsetget/set RandStream/set COM/set tscollection/set timeseries/set phytree/set daqdevice/set daqchild/set qfft/set imaqdevice/set imaqchild/set iviconfigurationstore/set icgroup/set icdevice/set instrument/set InputOutputModel/set DynamicSystem/set opcond.set dataset/set fdspec/set fdmeas/set fdline/set fdax/set vrworld/set vrnode/set vrfigure/set

Reference page in Help browser doc set

showImageOrMSRusingVOL.m

--- help for VolViewer/showImageOrMSRusingVOL ---

VOL=showImageOrMSRusingVOL(VOL,stackDirectory,varargin) VO, existing VolViewer object Remaining arguments are in pairs 'PathToVolViewer': default manually set the first time 'PathToWatchFile': default manually set the first time 'WatchFileNumber': default 1.00000, WARNING only GPU cards with lots of memory will actually load images into >1 at one time PathTo: by default images are loaded imageFiles: by default all images in the stack are opened msrFilename: if any of these are filled, then the associated file will be loaded instead of images tfnFilename: ditto slcFilename: ditto vvrFilename: ditto objFilename: ditto Commands: default empty. Cell array of commands to be applied having loaded the image/result etc. Usage VOL=imshowVOL('PathTo',D:\Shape_T1_only\Image_data\11to14DFS\1554'); % Creates object VOL=imshowVOL('VolViewerObject',VOL, 'PathTo','D:\Shape_T1_only\Image_data\11to14DFS\1554'); % uses object J.Andrew Bangham, 2012

MSRread2Matlab.m

MSR=MSRread2Matlab(PathName,FileName) uses msrfilereader to read MSR file and then converts vertex indexing to start from 1 instead of 0 Also see MSRwriteFromMatlab(MSR,PathName,FileName); J. Andrew Bangham, 2012

MSRwriteFromMatlab.m

MSRwriteFromMatlab(MSR,PathName,FileName) uses msrfilereader to read MSR file and then converts vertex indexing to start from 1 instead of 0 Also see MSRread2Matlab(PathName,FileName); J. Andrew Bangham, 2012

ScaleVolume.m

checkForVolViewer.m

## C:\Users\AB\DArT_Toolshed\ToolBag\dipum_toolbox_2.0

Contents.m

DIPUM Toolbox. Version 2.0 14-May-2009 MATLAB functions from the book Digital Image Processing Using MATLAB, by R.C. Gonzalez, R.E. Woods, and S.L. Eddins, Gatesmark Publishing, 2009. Book web site: http://www.imageprocessingplace.com Publisher web site: http://www.gatesmark.com/DIPUM2e.htm Release information. Readme - Information about current and previous versions. Image display and exploration. ice - Interactive Color Editor. rgbcube - Displays an RGB cube on the MATLAB desktop. Image file I/O movie2tifs - Creates a multiframe TIFF file from a MATLAB movie. seq2tifs - Creates a multi-frame TIFF file from a MATLAB sequence. tifs2movie - Create a MATLAB movie from a multiframe TIFF file. tifs2seq - Create a MATLAB sequence from a multi-frame TIFF file. Geometric transformations. imtransform2 - 2-D image transformation with fixed output location. pixeldup - Duplicates pixels of an image in both directions. pointgrid - Points arranged on a grid. reprotate - Rotate image repeatedly. vistform - Visualization transformation effect on set of points. Image registration. visreg - Visualize registered images. Pixel values and statistics. localmean - Computes an array of local means. statmoments - Computes statistical central moments of image histogram. Image analysis. bayesgauss - Bayes classifier for Gaussian patterns. bound2eight - Convert 4-connected boundary to 8-connected boundary. bound2four - Convert 8-connected boundary to 4-connected boundary. bound2im - Converts a boundary to an image. boundarydir - Determine the direction of a sequence of planar points. bsubsamp - Subsample a boundary. colorgrad - Computes the vector gradient of an RGB image. colorseg - Performs segmentation of a color image. connectpoly - Connects vertices of a polygon. cornerprocess - Processes the output of function cornermetric. diameter - Measure diameter and related properties of image regions. fchcode - Computes the Freeman chain code of a boundary. frdescp - Computes Fourier descriptors. ifrdescp - Computes inverse Fourier descriptors. im2minperpoly - Minimum perimeter polygon. imstack2vectors - Extracts vectors from an image stack. invmoments - Compute invariant moments of image. localthresh - Local thresholding. mahalanobis - Computes the Mahalanobis distance. movingthresh - Image segmentation using a moving average threshold. otsuthresh - Otsu's optimum threshold given a histogram. polyangles - Computes internal polygon angles. principalcomps - Principal-component vectors and related quantities. randvertex - Adds random noise to the vertices of a polygon. regiongrow - Perform segmentation by region growing. signature - Computes the signature of a boundary. specxture - Computes spectral texture of an image. splitmerge - Segment an image using a split-and-merge algorithm. statxture - Computes statistical measures of texture in an image. strsimilarity - Computes a similarity measure between two strings. x2majoraxis - Aligns coordinate x with the major axis of a region. Image compression. compare - Computes and displays the error between two matrices. cv2tifs - Decodes a TIFS2CV compressed image sequence. huff2mat - Decodes a Huffman encoded matrix. huffman - Builds a variable-length Huffman code for a symbol source. im2jpeg - Compresses an image using a JPEG approximation. im2jpeg2k - Compresses an image using a JPEG 2000 approximation. imratio - Computes the ratio of the bytes in two images/variables. jpeg2im - Decodes an IM2JPEG compressed image. jpeg2k2im - Decodes an IM2JPEG2K compressed image. lpc2mat - Decompresses a 1-D lossless predictive encoded matrix. mat2huff - Huffman encodes a matrix. mat2lpc - Compresses a matrix using 1-D lossles predictive coding. ntrop - Computes a first-order estimate of the entropy of a matrix. quantize - Quantizes the elements of a UINT8 matrix. showmo - Displays the motion vectors of a compressed image sequence. tifs2cv - Compresses a multi-frame TIFF image sequence. unravel - Decodes a variable-length bit stream. Image enhancement. adpmedian - Perform adaptive median filtering. gscale - Scales the intensity of the input image. intrans - Performs intensity (gray-level) transformations. Image noise. imnoise2 - Generates an array of random numbers with specified PDF. imnoise3 - Generates periodic noise. Linear filtering. dftfilt - Performs frequency domain filtering. spfilt - Performs linear and nonlinear spatial filtering. Linear 2-D filter design. bandfilter - Computes frequency domain band filters. cnotch - Generates circularly symmetric notch filters. hpfilter - Computes frequency domain highpass filters. lpfilter - Computes frequency domain lowpass filters. recnotch - Generates rectangular notch (axes) filters. Fuzzy logic. aggfcn - Aggregation function for a fuzzy system. approxfcn - Approximation function. bellmf - Bell-shaped membership function. defuzzify - Output of fuzzy system. fuzzyfilt - Fuzzy edge detector. fuzzysysfcn - Fuzzy system function. implfcns - Implication functions for a fuzzy system. lambdafcns - Lambda functions for a set of fuzzy rules. makefuzzyedgesys - Script to make MAT-file used by FUZZYFILT. onemf - Constant membership function (one). sigmamf - Sigma membership function. smf - S-shaped membership function. trapezmf - Trapezoidal membership function. triangmf - Triangular membership function. truncgaussmf - Truncated Gaussian membership function. zeromf - Constant membership function (zero). Morphological operations. endpoints - Computes end points of a binary image. Texture analysis. specxture - Computes spectral texture of an image. statxture - Computes statistical measures of texture in an image. Region-based processing. histroi - Computes the histogram of an ROI in an image. Wavelets. waveback - Computes inverse FWTs for multi-level decomposition. wavecopy - Fetches coefficients of a wavelet decomposition structure. wavecut - Zeroes coefficients in a wavelet decomposition structure. wavedisplay - Display wavelet decomposition coefficients. wavefast - Computes the FWT of a '3-D extended' 2-D array. wavefilter - Create wavelet decomposition and reconstruction filters. wavework - is used to edit wavelet decomposition structures. wavezero - Zeroes wavelet transform detail coefficients. Color space conversions. hsi2rgb - Converts an HSI image to RGB. rgb2hsi - Converts an RGB image to HSI. Array operations. dftuv - Computes meshgrid frequency matrices. paddedsize - Computes padded sizes useful for FFT-based filtering. Image types and type conversions. tofloat - Convert image to floating point. Miscellaneous functions. conwaylaws - Applies Conway's genetic laws to a single pixel. i2percentile - Computes a percentile given an intensity value. iseven - Determines which elements of an array are even numbers. isodd - Determines which elements of an array are odd numbers. manualhist - Generates a two-mode histogram interactively. timeit - Measure time required to run function. percentile2i - Computes an intensity value given a percentile. twomodegauss - Generates a two-mode Gaussian function.

Overloaded methods: mmreader/Contents VideoReader/Contents serial/Contents dioline/Contents digitalio/Contents daqdevice/Contents daqchild/Contents aochannel/Contents analogoutput/Contents analoginput/Contents aichannel/Contents videosource/Contents videoinput/Contents imaqdevice/Contents imaqchild/Contents visa/Contents udp/Contents tcpip/Contents iviconfigurationstore/Contents icgroup/Contents icdevice/Contents i2c/Contents gpib/Contents Bluetooth/Contents instrument/Contents

Readme.m

README file for the DIPUM Toolbox. These MATLAB functions were created for the book Digital Image Processing Using MATLAB, 2nd edition, by R.C. Gonzalez, R.E. Woods, and S.L. Eddins, Gatesmark Publishing, 2009. The functions supplement and extend the image processing functionality of MATLAB and the Image Processing Toolbox, both offered by The MathWorks. The P-code version of the DIPUM Toolbox --------------------------------------- The P-code version of the DIPUM Toolbox contains only executable MATLAB P-files. P-files may be executed as MATLAB functions just as M-files. Unlike M-files, however, neither the help text nor the source code is accessible. Complete source code listings for all functions are included in the book. The registered version of the DIPUM Toolbox ------------------------------------------- The registered version of the DIPUM Toolbox contains M-files with readable source code and help text. Users who want the M-files in electronic form may obtain, for a small fee, a password allowing them to download the registered toolbox. More information about both versions of the DIPUM Toolbox and details on how to obtain them are available at the book web site: http://www.imageprocessingplace.com/DIPUM_Toolbox_2/DIPUM_Toolbox_2.htm Requirements ------------ This release of the DIPUM Toolbox was developed and tested using the R2008b release of MATLAB and the Image Processing Toolbox. The DIPUM Toolbox is not supported for use with earlier versions of MATLAB or the Image Processing Toolbox. Most DIPUM functions require the Image Processing Toolbox. The DIPUM Toolbox works with all MATLAB platforms. It includes one MEX-file (UNRAVEL, which is used for Huffman decoding). Compiled binaries for this MEX-file are provided for all MATLAB platforms. Installation ------------ To install the DIPUM Toolbox, place the folder containing the functions on a local hard drive or a network drive accessible to your computer, and then include the folder location in the MATLAB path. To set the MATLAB path, start MATLAB and then select the File/Set Path menu item. Then select Add Folder. Use the navigation window to select the folder containing the functions. Click OK and then click Save. The functions will then be ready for use within MATLAB. Copyright --------- The DIPUM Toolbox is protected under U.S. and international copyright law. You may not transfer, publish, disclose, display, or otherwise make available either the free or the registered versions of the DIPUM Toolbox to other people. In particular, you may not place either version of the DIPUM Toolbox on an Internet site, a computer bulletin board, or an anonymous ftp directory from which it could be downloaded or copied by other people. Anyone may obtain the free version directly from the book's web site. Disclaimer of Warranty ---------------------- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. The DIPUM Toolbox was not created by The MathWorks, nor is it supported by The MathWorks. About Version 2.0 ----------------- Release date: 14-May-2009 Version 2.0 corresponds to the second edition of Digital Image Processing Using MATLAB. NEW FUNCTIONS Version 2.0 contains many new functions: * aggfcn - Aggregation function for a fuzzy system. * approxfcn - Approximation function. * bandfilter - Computes frequency domain band filters. * bellmf - Bell-shaped membership function. * boundarydir - Determine the direction of a sequence of planar points. * cnotch - Generates circularly symmetric notch filters. * cornerprocess - Processes the output of function cornermetric. * cv2tifs - Decodes a TIFS2CV compressed image sequence. * defuzzify - Output of fuzzy system. * fuzzyfilt - Fuzzy edge detector. * fuzzysysfcn - Fuzzy system function. * i2percentile - Computes a percentile given an intensity value. * im2minperpoly - Minimum perimeter polygon. * implfcns - Implication functions for a fuzzy system. * imtransform2 - 2-D image transformation with fixed output location. * iseven - Determines which elements of an array are even numbers. * isodd - Determines which elements of an array are odd numbers. * lambdafcns - Lambda functions for a set of fuzzy rules. * localmean - Computes an array of local means. * localthresh - Local thresholding. * makefuzzyedgesys - Script to make MAT-file used by FUZZYFILT. * movie2tifs - Creates a multiframe TIFF file from a MATLAB movie. * movingthresh - Image segmentation using a moving average threshold. * ntrop - Computes a first-order estimate of the entropy of a matrix. * onemf - Constant membership function (one). * otsuthresh - Otsu's optimum threshold given a histogram. * percentile2i - Computes an intensity value given a percentile. * pointgrid - Points arranged on a grid. * principalcomps - Principal-component vectors and related quantities. * recnotch - Generates rectangular notch (axes) filters. * reprotate - Rotate image repeatedly. * seq2tifs - Creates a multi-frame TIFF file from a MATLAB sequence. * showmo - Displays the motion vectors of a compressed image sequence. * sigmamf - Sigma membership function. * smf - S-shaped membership function. * tifs2cv - Compresses a multi-frame TIFF image sequence. * tifs2movie - Create a MATLAB movie from a multiframe TIFF file. * tifs2seq - Create a MATLAB sequence from a multi-frame TIFF file. * timeit - Measure time required to run function. * tofloat - Convert image to floating point. * trapezmf - Trapezoidal membership function. * triangmf - Triangular membership function. * truncgaussmf - Truncated Gaussian membership function. * visreg - Visualize registered images. * vistform - Visualization transformation effect on set of points. * wavedisplay - Display wavelet decomposition coefficients. * zeromf - Constant membership function (zero). MODIFIED FUNCTIONS These functions that existed in the first edition of the book have new or modified behavior or syntaxes: * bound2im - Support fewer input arguments. * dftfilt - Use single precision. * dftuv - Use single precision. * endpoints - Use revised definition of end points. * im2jpeg - Support different bit depths. * imnoise3 - Fix incorrect computation. * intrans - Use single precision. * jpeg2im - Support different bit depths. * lpfilter - Use single precision. * regiongrow - Use single precision. * spfilt - Use single precision. * waveback - Support 3-D input. * wavefilter - Support 3-D input. Many DIPUM Toolbox functions were modified because of changes in MATLAB since the publication of the first edition, or were modified to clean up or simplify the code. Common changes include using && and || instead of & and |, removing unused variable assignments, reorganizing code into subfunctions, using hypot, and using bsxfun instead of repmat. Modified functions include adpmedian, bayesgauss, bound2eight, bound2im, bsubsamp, colorgrad, colorseg, covmatrix, fchcode, fwtcompare, gscale, huff2mat, huffman, ifrdescp, ifwtcompare, im2jpeg2k, imnoise2, imratio, imstack2vectors, intline, intrans, invmoments, jpeg2k2im, lpfilter, mahalanobis, mat2huff, paddedsize, polyangles, quantize, regiongrow, signature, spfilt, splitmerge, statmoments, strsimilarity, wave2gray, waveback, wavefast, wavefilter, and wavework. Function ice was modified according to the output of GUIDE in MATLAB R2008b. MEX function unravel was modified to use the latest MEX API calls and to use platform-independent typedefs. DELETED FUNCTIONS Several functions have been deleted from the DIPUM Toolbox: * boundaries - Replaced by Image Processing Toolbox function bwboundaries. * dftcorr - No longer used in the book. * entropy - Replaced by ntrop. * hough - Replaced by Image Processing Toolbox function. * houghlines - Replaced by Image Processing Toolbox function. * houghpeaks - Replaced by Image Processing Toolbox function. * houghpixels - Not used in the book. * minperpoly - Replaced by im2minperpoly. * princomp - Replaced by principalcomps. * vistformfwd - Replaced by vistform. About Version 1.1.4 ------------------- Release date: 15-July-2006 Changes: * bayesgauss: Corrected typo in help text. * ifrdescp: Corrected typo in help text. * im2jpeg: Corrected bug in end-of-block computation. * imnoise2: Corrected bug in the lognormal computation. * mahalanobis: Corrected typo in help text. * pixeldup: Corrected typo in comment. * rgb2hsi: Corrected typo in comment. About Version 1.1.3 ------------------- Release date: 15-Dec-2004 Changes: * bayesgauss: Corrected bug in the optimized version that was released in DIPUM Toolbox 1.1. About Version 1.1.2 ------------------- Release date: 04-Nov-2004 Changes: * bayesgauss: Revised help text and some comments in the code. * bsubsamp: Corrected indexing errors that occurred under some conditions. * ifrdescp: Revised help text. * imnoise3: Revised help text. * lpfilter: Removed a superfluous output variable. * statxture: Removed unnecessary brackets surrounding output variable. About Version 1.1.1 ------------------- Release date: 04-Jun-2004 Changes: * Added missing ice.fig file to toolbox distribution. About Version 1.1 ----------------- Release date: 10-Mar-2004 Changes: * Function bayesgauss was modified to improve performance. About Version 1.0 ----------------- Release date: 01-Dec-2003 This initial release of the DIPUM Toolbox coincides with the initial publication of Digital Image Processing Using MATLAB.

adpmedian.m

ADPMEDIAN Perform adaptive median filtering. F = ADPMEDIAN(G, SMAX) performs adaptive median filtering of image G. The median filter starts at size 3-by-3 and iterates up to size SMAX-by-SMAX. SMAX must be an odd integer greater than 1.

aggfcn.m

AGGFCN Aggregation function for a fuzzy system. QA = AGGFCN(Q) creates an aggregation function, QA, from a set of implication functions, Q. Q is a cell array of function handles as returned by IMPLFCNS. QA is a function handle that can be called with a single input V using the syntax: q = QA(V)

approxfcn.m

APPROXFCN Approximation function. G = APPROXFCN(F, RANGE) returns a function handle, G, that approximates the function handle F by using a lookup table. RANGE is an M-by-2 matrix specifying the input range for each of the M inputs to F.

average.m

AVERAGE Computes the average value of an array. AV = AVERAGE(A) computes the average value of input array, A, which must be a 1-D or 2-D array.

bandfilter.m

BANDFILTER Computes frequency domain band filters. Parameters used in the filter definitions (see Table 4.3 in DIPUM 2e for more details about these parameters): M: Number of rows in the filter. N: Number of columns in the filter. D0: Radius of the center of the band. W: "Width" of the band. W is the true width only for ideal filters. For the other two filters this parameter acts more like a smooth cutoff. n: Order of the Butterworth filter if one is specified. W and n interplay to determine the effective broadness of the reject or pass band. Higher values of both these parameters result in broader bands. Valid values of BAND are: 'reject' Bandreject filter. 'pass' Bandpass filter. One of these two values must be specified for BAND. H = BANDFILTER('ideal', BAND, M, N, D0, W) computes an M-by-N ideal bandpass or bandreject filter, depending on the value of BAND. H = BANDFILTER('btw', BAND, M, N, D0, W, n) computes an M-by-N Butterworth filter of order n. The filter is either bandpass or bandreject, depending on the value of BAND. The default value of n is 1. H = BANDFILTER('gaussian', BAND, M, N, D0, W) computes an M-by-N gaussian filter. The filter is either bandpass or bandreject, depending on BAND. H is of floating point class single. It is returned uncentered for consistency with filtering function dftfilt. To view H as an image or mesh plot, it should be centered using Hc = fftshift(H).

bayesgauss.m

BAYESGAUSS Bayes classifier for Gaussian patterns. D = BAYESGAUSS(X, CA, MA, P) computes the Bayes decision functions of the n-dimensional patterns in the rows of X. CA is an array of size n-by-n-by-W containing W covariance matrices of size n-by-n, where W is the number of classes. MA is an array of size n-by-W, whose columns are the corresponding mean vectors. A covariance matrix and a mean vector must be specified for each class. X is of size K-by-n, where K is the number of patterns to be classified. P is a 1-by-W array, containing the probabilities of occurrence of each class. If P is not included in the argument, the classes are assumed to be equally likely. D is a column vector of length K. Its ith element is the class number assigned to the ith vector in X during classification.

bellmf.m

BELLMF Bell-shaped membership function. MU = BELLMF(Z, A, B) computes the bell-shaped fuzzy membership function. Z is the input variable and can be a vector of any length. A and B are scalar shape parameters, ordered such that A <= B. MU = SMF(Z, A, B), Z < B MU = SMF(2*B - Z, A, B), B <= Z

bound2eight.m

BOUND2EIGHT Convert 4-connected boundary to 8-connected boundary. RC_NEW = BOUND2EIGHT(RC) converts a four-connected boundary to an eight-connected boundary. RC is a P-by-2 matrix, each row of which contains the row and column coordinates of a boundary pixel. RC must be a closed boundary; in other words, the last row of RC must equal the first row of RC. BOUND2EIGHT removes boundary pixels that are necessary for four-connectedness but not necessary for eight-connectedness. RC_NEW is a Q-by-2 matrix, where Q <= P.

bound2four.m

BOUND2FOUR Convert 8-connected boundary to 4-connected boundary. RC_NEW = BOUND2FOUR(RC) converts an eight-connected boundary to a four-connected boundary. RC is a P-by-2 matrix, each row of which contains the row and column coordinates of a boundary pixel. BOUND2FOUR inserts new boundary pixels wherever there is a diagonal connection.

bound2im.m

BOUND2IM Converts a boundary to an image. IMAGE = BOUND2IM(b) converts b, an np-by-2 array containing the integer coordinates of a boundary, into a binary image with 1s in the locations of the coordinates in b and 0s elsewhere. The height and width of the image are equal to the Mmin + H and Nmin + W, where Mmin = min(b(:,1)) - 1, N = min(b(:,2)) - 1, and H and W are the height and width of the boundary. In other words, the image created is the smallest image that will encompass the boundary while maintaining the its original coordinate values. IMAGE = BOUND2IM(b, M, N) places the boundary in a region of size M-by-N. M and N must satisfy the following conditions: M >= max(b(:,1)) - min(b(:,1)) + 1 N >= max(b(:,2)) - min(b(:,2)) + 1 Typically, M = size(f, 1) and N = size(f, 2), where f is the image from which the boundary was extracted. In this way, the coordinates of IMAGE and f are registered with respect to each other.

boundarydir.m

BOUNDARYDIR Determine the direction of a sequence of planar points. [DIR] = BOUNDARYDIR(X, Y) determines the direction of travel of a closed, nonintersecting sequence of planar points with coordinates contained in column vectors X and Y. Values of DIR are 'cw' (clockwise) and 'ccw' (counterclockwise). The direction of travel is with respect to the image coordinate system defined in Chapter 2 of the book. [DIR, X0, Y0] = BOUNDARYDIR(X, Y, ORDEROUT) determines the direction DIR of the input sequence, and also outputs the sequence with its direction of travel as specified in ORDEROUT. Valid values of this parameter as 'cw' and 'ccw'. The coordinates of the output sequence are column vectors X0 and Y0. The input sequence is assumed to be nonintersecting, and it cannot have duplicate points, with the exception of the first and last points possibly being the same, a condition often resulting from boundary-following functions, such as bwboundaries.

bsubsamp.m

BSUBSAMP Subsample a boundary. [S, SUNIT] = BSUBSAMP(B, GRIDSEP) subsamples the boundary B by assigning each of its points to the grid node to which it is closest. The grid is specified by GRIDSEP, which is the separation in pixels between the grid lines. For example, if GRIDSEP = 2, there are two pixels in between grid lines. So, for instance, the grid points in the first row would be at (1,1), (1,4), (1,6), ..., and similarly in the y direction. The value of GRIDSEP must be an integer. The boundary is specified by a set of coordinates in the form of an np-by-2 array. It is assumed that the boundary is one pixel thick and that it is ordered in a clockwise or counterclockwise sequence. Output S is the subsampled boundary. Output SUNIT is normalized so that the grid separation is unity. This is useful for obtaining the Freeman chain code of the subsampled boundary. The outputs are in the same order (clockwise or counterclockwise) as the input. There are no duplicate points in the output.

changeclass.m

CHANGECLASS changes the storage class of an image. I2 = CHANGECLASS(CLASS, I); RGB2 = CHANGECLASS(CLASS, RGB); BW2 = CHANGECLASS(CLASS, BW); X2 = CHANGECLASS(CLASS, X, 'indexed');

cnotch.m

CNOTCH Generates circularly symmetric notch filters. H = CNOTCH(TYPE, NOTCH, M, N, C, D0, n) generates a notch filter of size M-by-N. C is a K-by-2 matrix with K pairs of frequency domain coordinates (u, v) that define the centers of the filter notches (when specifying filter locations, remember that coordinates in MATLAB run from 1 to M and 1 to N). Coordinates (u, v) are specified for one notch only. The corresponding symmetric notches are generated automatically. D0 is the radius (cut-off frequency) of the notches. It can be specified as a scalar, in which case it is used in all K notch pairs, or it can be a vector of length K, containing an individual cutoff value for each notch pair. n is the order of the Butterworth filter if one is specified. Valid values of TYPE are: 'ideal' Ideal notchpass filter. n is not used. 'btw' Butterworth notchpass filter of order n. The default value of n is 1. 'gaussian' Gaussian notchpass filter. n is not used. Valid values of NOTCH are: 'reject' Notchreject filter. 'pass' Notchpass filter. One of these two values must be specified for NOTCH. H is of floating point class single. It is returned uncentered for consistency with filtering function dftfilt. To view H as an image or mesh plot, it should be centered using Hc = fftshift(H).

colorgrad.m

COLORGRAD Computes the vector gradient of an RGB image. [VG, VA, PPG] = COLORGRAD(F, T) computes the vector gradient, VG, and corresponding angle array, VA, (in radians) of RGB image F. It also computes PPG, the per-plane composite gradient obtained by summing the 2-D gradients of the individual color planes. Input T is a threshold in the range [0, 1]. If it is included in the argument list, the values of VG and PPG are thresholded by letting VG(x,y) = 0 for values <= T and VG(x,y) = VG(x,y) otherwise. Similar comments apply to PPG. If T is not included in the argument list then T is set to 0. Both output gradients are scaled to the range [0, 1].

colorseg.m

COLORSEG Performs segmentation of a color image. S = COLORSEG('EUCLIDEAN', F, T, M) performs segmentation of color image F using a Euclidean measure of similarity. M is a 1-by-3 vector representing the average color used for segmentation (this is the center of the sphere in Fig. 6.26 of DIPUM). T is the threshold against which the distances are compared. S = COLORSEG('MAHALANOBIS', F, T, M, C) performs segmentation of color image F using the Mahalanobis distance as a measure of similarity. C is the 3-by-3 covariance matrix of the sample color vectors of the class of interest. See function covmatrix for the computation of C and M. S is the segmented image (a binary matrix) in which 0s denote the background.

compare.m

COMPARE Computes and displays the error between two matrices. RMSE = COMPARE(F1, F2, SCALE) returns the root-mean-square error between inputs F1 and F2, displays a histogram of the difference, and displays a scaled difference image. When SCALE is omitted, a scale factor of 1 is used.

connectpoly.m

CONNECTPOLY Connects vertices of a polygon. C = CONNECTPOLY(X, Y) connects the points with coordinates given in X and Y with straight lines. These points are assumed to be a sequence of polygon vertices organized in the clockwise or counterclockwise direction. The output, C, is the set of points along the boundary of the polygon in the form of an nr-by-2 coordinate sequence in the same direction as the input. The last point in the sequence is equal to the first.

conwaylaws.m

CONWAYLAWS Applies Conway's genetic laws to a single pixel. OUT = CONWAYLAWS(NHOOD) applies Conway's genetic laws to a single pixel and its 3-by-3 neighborhood, NHOOD.

cornerprocess.m

CORNERPROCESS Processes the output of function cornermetric. CP = CORNERPROCESS(C, T, Q) postprocesses C, the output of function CORNERMETRIC, with the objective of reducing the number of irrelevant corner points (with respect to threshold T) and the number of multiple corners in a neighborhood of size Q-by-Q. If there are multiple corner points contained within that neighborhood, they are eroded morphologically to one corner point. A corner point is said to have been found at coordinates (I, J) if C(I,J) > T. A good practice is to normalize the values of C to the range [0 1], in im2double format before inputting C into this function. This facilitates interpretation of the results and makes thresholding more intuitive.

covmatrix.m

COVMATRIX Computes the covariance matrix and mean vector. [C, M] = COVMATRIX(X) computes the covariance matrix C and the mean vector M of a vector population organized as the rows of matrix X. This matrix is of size K-by-N, where K is the number of samples and N is their dimensionality. C is of size N-by-N and M is of size N-by-1. If the population contains a single sample, this function outputs M = X and C as an N-by-N matrix of NaN's because the definition of an unbiased estimate of the covariance matrix divides by K - 1.

cv2tifs.m

CV2TIFS Decodes a TIFS2CV compressed image sequence. Y = CV2TIFS(Y, F) decodes compressed sequence Y (a structure generated by TIFS2CV) and creates a multiframe TIFF file F. See also TIFS2CV.

defuzzify.m

DEFUZZIFY Output of fuzzy system. OUT = DEFUZZIFY(QA, VRANGE) transforms the aggregation function QA into a fuzzy result using the center-of-gravity method. QA is a function handle as returned by AGGFCN. VRANGE is a two-element vector specifying the range of input values for QA. OUT is the scalar result.

dftfilt.m

DFTFILT Performs frequency domain filtering. g = DFTFILT(f, H, CLASSOUT) filters f in the frequency domain using the filter transfer function H. The output, g, is the filtered image, which has the same size as f. Valid values of CLASSOUT are 'original' The ouput is of the same class as the input. This is the default if CLASSOUT is not included in the call. 'fltpoint' The output is floating point of class single, unless both f and H are of class double, in which case the output also is of class double. DFTFILT automatically pads f to be the same size as H. Both f and H must be real. In addition, H must be an uncentered, circularly-symmetric filter function.

dftuv.m

DFTUV Computes meshgrid frequency matrices. [U, V] = DFTUV(M, N) computes meshgrid frequency matrices U and V. U and V are useful for computing frequency-domain filter functions that can be used with DFTFILT. U and V are both M-by-N and of class single.

diameter.m

DIAMETER Measure diameter and related properties of image regions. S = DIAMETER(L) computes the diameter, the major axis endpoints, the minor axis endpoints, and the basic rectangle of each labeled region in the label matrix L. Positive integer elements of L correspond to different regions. For example, the set of elements of L equal to 1 corresponds to region 1; the set of elements of L equal to 2 corresponds to region 2; and so on. S is a structure array of length max(L(:)). The fields of the structure array include: Diameter MajorAxis MinorAxis BasicRectangle The Diameter field, a scalar, is the maximum distance between any two pixels in the corresponding region. The MajorAxis field is a 2-by-2 matrix. The rows contain the row and column coordinates for the endpoints of the major axis of the corresponding region. The MinorAxis field is a 2-by-2 matrix. The rows contain the row and column coordinates for the endpoints of the minor axis of the corresponding region. The BasicRectangle field is a 4-by-2 matrix. Each row contains the row and column coordinates of a corner of the region-enclosing rectangle defined by the major and minor axes. For more information about these measurements, see Section 11.2.1 of Digital Image Processing, by Gonzalez and Woods, 2nd edition, Prentice Hall.

endpoints.m

ENDPOINTS Computes end points of a binary image. G = ENDPOINTS(F) computes the end points of the binary image F and returns them in the binary image G.

fchcode.m

FCHCODE Computes the Freeman chain code of a boundary. C = FCHCODE(B) computes the 8-connected Freeman chain code of a set of 2-D coordinate pairs contained in B, an np-by-2 array. C is a structure with the following fields: c.fcc = Freeman chain code (1-by-np) c.diff = First difference of code c.fcc (1-by-np) c.mm = Integer of minimum magnitude from c.fcc (1-by-np) c.diffmm = First difference of code c.mm (1-by-np) c.x0y0 = Coordinates where the code starts (1-by-2) C = FCHCODE(B, CONN) produces the same outputs as above, but with the code connectivity specified in CONN. CONN can be 8 for an 8-connected chain code, or CONN can be 4 for a 4-connected chain code. Specifying CONN = 4 is valid only if the input sequence, B, contains transitions with values 0, 2, 4, and 6, exclusively. If it does not, an error is issued. See table below. C = FHCODE(B, CONN, DIR) produces the same outputs as above, but, in addition, the desired code direction is specified. Values for DIR can be: 'same' Same as the order of the sequence of points in b. This is the default. 'reverse' Outputs the code in the direction opposite to the direction of the points in B. The starting point for each DIR is the same. The elements of B are assumed to correspond to a 1-pixel-thick, fully-connected, closed boundary. B cannot contain duplicate coordinate pairs, except in the first and last positions, which is a common feature of boundary tracing programs. FREEMAN CHAIN CODE REPRESENTATION The table on the left shows the 8-connected Freeman chain codes corresponding to allowed deltax, deltay pairs. An 8-chain is converted to a 4-chain if (1) conn = 4; and (2) only transitions 0, 2, 4, and 6 occur in the 8-code. Note that dividing 0, 2, 4, and 6 by 2 produce the 4-code. See Fig. 12.2 for an explanation of the directional 4- and 8-codes. ----------------------- ---------------- deltax | deltay | 8-code corresp 4-code ----------------------- ---------------- 0 1 0 0 -1 1 1 -1 0 2 1 -1 -1 3 0 -1 4 2 1 -1 5 1 0 6 3 1 1 7 ----------------------- ---------------- The formula z = 4*(deltax + 2) + (deltay + 2) gives the following sequence corresponding to rows 1-8 in the preceding table: z = 11,7,6,5,9,13,14,15. These values can be used as indices into the table, improving the speed of computing the chain code. The preceding formula is not unique, but it is based on the smallest integers (4 and 2) that are powers of 2.

frdescp.m

FRDESCP Computes Fourier descriptors. Z = FRDESCP(S) computes the Fourier descriptors of S, which is an np-by-2 sequence of ordered coordinates describing a boundary. Due to symmetry considerations when working with inverse Fourier descriptors based on fewer than np terms, the number of points in S when computing the descriptors must be even. If the number of points is odd, FRDESCP duplicates the end point and adds it at the end of the sequence. If a different treatment is desired, the sequence must be processed externally so that it has an even number of points. See function IFRDESCP for computing the inverse descriptors.

fuzzyfilt.m

FUZZYFILT Fuzzy edge detector. G = FUZZYFILT(F) implements the rule-based fuzzy filter discussed in the "Using Fuzzy Sets for Spatial Filtering" section of Digital Image Processing Using MATLAB/2E. F and G are the input and filtered images, respectively. FUZZYFILT is implemented using precomputed fuzzy system function handle saved in the MAT-file fuzzyedgesys.mat. The M-script makefuzzyedgesys.m contains the code used to create the fuzzy system function.

fuzzysysfcn.m

FUZZYSYSFCN Fuzzy system function. F = FUZZYSYSFCN(INMF, OUTMF, VRANGE, OP) creates a fuzzy system function, F, corresponding to a set of rules and output membership functions. INMF is an M-by-N matrix of input membership function handles. M is the number of rules, and N is the number of fuzzy system inputs. OUTMF is a cell array containing output membership functions. numel(OUTMF) can be either M or M + 1. If it is M + 1, then the "extra" output membership function is used for an automatically computed "else rule." VRANGE is a two-element vector specifying the valid range of input values for the output membership functions. OP is a function handle specifying how to combine the antecedents for each rule. OP can be either @min or @max. If OP is omitted, then @min is used. The output, F, is a function handle that computes the fuzzy system's output, given a set of inputs, using the syntax: out = F(Z1, Z2, Z3, ..., ZN)

fwtcompare.m

FWTCOMPARE Compare wavedec2 and wavefast. [RATIO, MAXDIFF] = FWTCOMPARE(F, N, WNAME) compares the operation of Wavelet Toolbox function WAVEDEC2 and custom function WAVEFAST. INPUTS: F Image to be transformed. N Number of scales to compute. WNAME Wavelet to use. OUTPUTS: RATIO Execution time ratio (custom/toolbox) MAXDIFF Maximum coefficient difference.

gmean.m

GMEAN Geometric mean of columns. V = GMEAN(A) computes the geometric mean of the columns of A. V is a row vector with size(A,2) elements. Sample M-file used in Chapter 3.

gscale.m

GSCALE Scales the intensity of the input image. G = GSCALE(F, 'full8') scales the intensities of F to the full 8-bit intensity range [0, 255]. This is the default if there is only one input argument. G = GSCALE(F, 'full16') scales the intensities of F to the full 16-bit intensity range [0, 65535]. G = GSCALE(F, 'minmax', LOW, HIGH) scales the intensities of F to the range [LOW, HIGH]. These values must be provided, and they must be in the range [0, 1], independently of the class of the input. GSCALE performs any necessary scaling. If the input is of class double, and its values are not in the range [0, 1], then GSCALE scales it to this range before processing. The class of the output is the same as the class of the input.

histroi.m

HISTROI Computes the histogram of an ROI in an image. [P, NPIX] = HISTROI(F, C, R) computes the histogram, P, of a polygonal region of interest (ROI) in image F. The polygonal region is defined by the column and row coordinates of its vertices, which are specified (sequentially) in vectors C and R, respectively. All pixels of F must be >= 0. Parameter NPIX is the number of pixels in the polygonal region.

hpfilter.m

HPFILTER Computes frequency domain highpass filters. H = HPFILTER(TYPE, M, N, D0, n) creates the transfer function of a highpass filter, H, of the specified TYPE and size (M-by-N). Valid values for TYPE, D0, and n are: 'ideal' Ideal highpass filter with cutoff frequency D0. n need not be supplied. D0 must be positive. 'btw' Butterworth highpass filter of order n, and cutoff D0. The default value for n is 1.0. D0 must be positive. 'gaussian' Gaussian highpass filter with cutoff (standard deviation) D0. n need not be supplied. D0 must be positive. H is of floating point class single. It is returned uncentered for consistency with filtering function dftfilt. To view H as an image or mesh plot, it should be centered using Hc = fftshift(H).

hsi2rgb.m

HSI2RGB Converts an HSI image to RGB. RGB = HSI2RGB(HSI) converts an HSI image to RGB, where HSI is assumed to be of class double with: HSI(:, :, 1) = hue image, assumed to be in the range [0, 1] by having been divided by 2*pi. HSI(:, :, 2) = saturation image, in the range [0, 1]. HSI(:, :, 3) = intensity image, in the range [0, 1]. The components of the output image are: RGB(:, :, 1) = red. RGB(:, :, 2) = green. RGB(:, :, 3) = blue.

huff2mat.m

HUFF2MAT Decodes a Huffman encoded matrix. X = HUFF2MAT(Y) decodes a Huffman encoded structure Y with uint16 fields: Y.min Minimum value of X plus 32768 Y.size Size of X Y.hist Histogram of X Y.code Huffman code The output X is of class double. See also MAT2HUFF.

huffman.m

HUFFMAN Builds a variable-length Huffman code for a symbol source. CODE = HUFFMAN(P) returns a Huffman code as binary strings in cell array CODE for input symbol probability vector P. Each word in CODE corresponds to a symbol whose probability is at the corresponding index of P. Based on huffman5 by Sean Danaher, University of Northumbria, Newcastle UK. Available at the MATLAB Central File Exchange: Category General DSP in Signal Processing and Communications.

i2percentile.m

I2PERCENTILE Computes a percentile given an intensity value. P = I2PERCENTILE(H, I) Given an intensity value, I, and a histogram, H, this function computes the percentile, P, that I represents for the population of intensities governed by histogram H. I must be in the range [0, 1], independently of the class of the image from which the histogram was obtained. P is returned as a value in the range [0 1]. To convert it to a percentile multiply it by 100. By definition, I = 0 represents the 0th percentile and I = 1 represents 100th percentile. Example: Suppose that h is a uniform histogram of an uint8 image. Typing P = i2percentile(h, 127/255) would return P = 0.5, indicating that the input intensity is in the 50th percentile. See also function percentile2i.

ice.m

ICE Interactive Color Editor. OUT = ICE('Property Name', 'Property Value', ...) transforms an image's color components based on interactively specified mapping functions. Inputs are Property Name/Property Value pairs: Name Value ------------ ----------------------------------------------- 'image' An RGB or monochrome input image to be transformed by interactively specified mappings. 'space' The color space of the components to be modified. Possible values are 'rgb', 'cmy', 'hsi', 'hsv', 'ntsc' (or 'yiq'), 'ycbcr'. When omitted, the RGB color space is assumed. 'wait' If 'on' (the default), OUT is the mapped input image and ICE returns to the calling function or workspace when closed. If 'off', OUT is the handle of the mapped input image and ICE returns immediately. EXAMPLES: ice OR ice('wait', 'off') % Demo user interface ice('image', f) % Map RGB or mono image ice('image', f, 'space', 'hsv') % Map HSV of RGB image g = ice('image', f) % Return mapped image g = ice('image', f, 'wait', 'off'); % Return its handle ICE displays one popup menu selectable mapping function at a time. Each image component is mapped by a dedicated curve (e.g., R, G, or B) and then by an all-component curve (e.g., RGB). Each curve's control points are depicted as circles that can be moved, added, or deleted with a two- or three-button mouse: Mouse Button Editing Operation ------------ ----------------------------------------------- Left Move control point by pressing and dragging. Middle Add and position a control point by pressing and dragging. (Optionally Shift-Left) Right Delete a control point. (Optionally Control-Left) Checkboxes determine how mapping functions are computed, whether the input image and reference pseudo- and full-color bars are mapped, and the displayed reference curve information (e.g., PDF): Checkbox Function ------------ ----------------------------------------------- Smooth Checked for cubic spline (smooth curve) interpolation. If unchecked, piecewise linear. Clamp Ends Checked to force the starting and ending curve slopes in cubic spline interpolation to 0. No effect on piecewise linear. Show PDF Display probability density function(s) [i.e., histogram(s)] of the image components affected by the mapping function. Show CDF Display cumulative distributions function(s) instead of PDFs. <Note: Show PDF/CDF are mutually exclusive.> Map Image If checked, image mapping is enabled; else not. Map Bars If checked, pseudo- and full-color bar mapping is enabled; else display the unmapped bars (a gray wedge and hue wedge, respectively). Mapping functions can be initialized via pushbuttons: Button Function ------------ ----------------------------------------------- Reset Init the currently displayed mapping function and uncheck all curve parameters. Reset All Initialize all mapping functions.

ice_stand_alone.m

ICE M-file for ice.fig ICE, by itself, creates a new ICE or raises the existing singleton*. H = ICE returns the handle to a new ICE or the handle to the existing singleton*. ICE('Property','Value',...) creates a new ICE using the given property value pairs. Unrecognized properties are passed via varargin to ice_OpeningFcn. This calling syntax produces a warning when there is an existing singleton*. ICE('CALLBACK') and ICE('CALLBACK',hObject,...) call the local function named CALLBACK in ICE.M with the given input arguments. *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one instance to run (singleton)". See also: GUIDE, GUIDATA, GUIHANDLES

ifrdescp.m

IFRDESCP Computes inverse Fourier descriptors. S = IFRDESCP(Z, ND) computes the inverse Fourier descriptors of of Z, which is a sequence of Fourier descriptor obtained, for example, by using function FRDESCP. ND is the number of descriptors used to compute the inverse; ND must be an even integer no greater than length(Z), and length(Z) must be even also. If ND is omitted, it defaults to length(Z). The output, S, is matrix of size length(Z)-by-2 containing the coordinates of a closed boundary.

ifwtcompare.m

IFWTCOMPARE Compare waverec2 and waveback. [RATIO, MAXDIFF] = IFWTCOMPARE(F, N, WNAME) compares the operation of Wavelet Toolbox function WAVEREC2 and custom function WAVEBACK. INPUTS: F Image to transform and inverse transform. N Number of scales to compute. WNAME Wavelet to use. OUTPUTS: RATIO Execution time ratio (custom/toolbox). MAXDIFF Maximum generated image difference.

im2jpeg.m

IM2JPEG Compresses an image using a JPEG approximation. Y = IM2JPEG(X, QUALITY) compresses image X based on 8 x 8 DCT transforms, coefficient quantization, and Huffman symbol coding. Input BITS is the bits/pixel used for the unsigned integer input; QUALITY determines the amount of information that is lost and compression achieved. Y is an encoding structure containing fields: Y.size Size of X Y.bits Bits/pixel of X Y.numblocks Number of 8-by-8 encoded blocks Y.quality Quality factor (as percent) Y.huffman Huffman encoding structure, as returned by MAT2HUFF See also JPEG2IM.

im2jpeg2k.m

IM2JPEG2K Compresses an image using a JPEG 2000 approximation. Y = IM2JPEG2K(X, N, Q) compresses image X using an N-scale JPEG 2K wavelet transform, implicit or explicit coefficient quantization, and Huffman symbol coding augmented by zero run-length coding. If quantization vector Q contains two elements, they are assumed to be implicit quantization parameters; else, it is assumed to contain explicit subband step sizes. Y is an encoding structure containing Huffman-encoded data and additional parameters needed by JPEG2K2IM for decoding. See also JPEG2K2IM.

im2minperpoly.m

IM2MINPERPOLY Minimum perimeter polygon. [X, Y, R] = IM2MINPERPOLY(B, CELLSIZE) outputs in column vectors X and Y the coordinates of the vertices of the minimum perimeter polygon circumscribing a single binary region or a (nonintersecting) boundary contained in image B. The background in B must be 0, and the region or boundary must have values equal to 1. If instead of an image, B, a list of ordered vertices is available, link the vertices using function connectpoly and then use function bound2im to generate a binary image B containing the boundary. R is the region extracted from the image, from which the MPP will be computed (see Figs. 12.5(c) and 12.6(e)). Displaying this region is a good approach to determine interactively a satisfactory value for CELLSIZE. Parameter CELLSIZE is the size of the square cells that enclose the boundary of the region in B. The value of CELLSIZE must be a positive integer greater than 1. See Section 12.2.2 in the book for further details on this parameter, as well as a description and references for the algorithm.

imnoise2.m

IMNOISE2 Generates an array of random numbers with specified PDF. R = IMNOISE2(TYPE, M, N, A, B) generates an array, R, of size M-by-N, whose elements are random numbers of the specified TYPE with parameters A and B. If only TYPE is included in the input argument list, a single random number of the specified TYPE and default parameters shown below is generated. If only TYPE, M, and N are provided, the default parameters shown below are used. If M = N = 1, IMNOISE2 generates a single random number of the specified TYPE and parameters A and B. Valid values for TYPE and parameters A and B are: 'uniform' Uniform random numbers in the interval (A, B). The default values are (0, 1). 'gaussian' Gaussian random numbers with mean A and standard deviation B. The default values are A = 0, B = 1. 'salt & pepper' Salt and pepper numbers of amplitude 0 with probability Pa = A, and amplitude 1 with probability Pb = B. The default values are Pa = Pb = A = B = 0.05. Note that the noise has values 0 (with probability Pa = A) and 1 (with probability Pb = B), so scaling is necessary if values other than 0 and 1 are required. The noise matrix R is assigned three values. If R(x, y) = 0, the noise at (x, y) is pepper (black). If R(x, y) = 1, the noise at (x, y) is salt (white). If R(x, y) = 0.5, there is no noise assigned to coordinates (x, y). 'lognormal' Lognormal numbers with offset A and shape parameter B. The defaults are A = 1 and B = 0.25. 'rayleigh' Rayleigh noise with parameters A and B. The default values are A = 0 and B = 1. 'exponential' Exponential random numbers with parameter A. The default is A = 1. 'erlang' Erlang (gamma) random numbers with parameters A and B. B must be a positive integer. The defaults are A = 2 and B = 5. Erlang random numbers are approximated as the sum of B exponential random numbers.

imnoise3.m

IMNOISE3 Generates periodic noise. [r, R, S] = IMNOISE3(M, N, C, A, B), generates a spatial sinusoidal noise pattern, r, of size M-by-N, its Fourier transform, R, and spectrum, S. The remaining parameters are: C is a K-by-2 matrix with K pairs of frequency domain coordinates (u, v) that define the locations of impulses in the frequency domain. The locations are with respect to the frequency rectangle center at [floor(M/2) + 1, floor(N/2) + 1], where the use of function floor is necessary to guarantee that all values of (u, v) are integers, as required by all Fourier formulations in the book. The impulse locations are specified as integer increments with respect to the center. For example, if M = N = 512, then the center is at (257, 257). To specify an impulse at (280, 300) we specify the pair (23, 43); i.e., 257 + 23 = 280, and 257 + 43 = 300. Only one pair of coordinates is required for each impulse. The conjugate pairs are generated automatically. A is a 1-by-K vector that contains the amplitude of each of the K impulse pairs. If A is not included in the argument, the default used is A = ONES(1, K). B is then automatically set to its default values (see next paragraph). The value specified for A(j) is associated with the coordinates in C(j, :). B is a K-by-2 matrix containing the Bx and By phase components for each impulse pair. The default value for B is zeros(K, 2).

implfcns.m

IMPLFCNS Implication functions for a fuzzy system. Q = IMPLFCNS(L, OUTMF, Z1, Z2, ..., ZN) creates a set of implication functions from a set of lambda functions L, a set of output member functions OUTMF, and a set of fuzzy system inputs Z1, Z2, ..., ZN. L is a cell array of rule-strength function handles as returned by LAMBDAFCNS. OUTMF is a cell array of output membership functions. The number of elements of OUTMF can either be numel(L) or numel(L)+1. If numel(OUTMF) is numel(L)+1, then the "extra" membership function is applied to an automatically computed "else rule." (See Section 3.6.3.). The inputs Z1, Z2, etc., can all be scalars, or they can all be vectors of the same size (i.e., these vectors would contain multiple values for each of the inputs). Q is a 1-by-numel(OUTMF) cell array of implication function handles. Call the i-th implication function on an input V using the syntax: q_i = Q{i}(V)

improd.m

IMPROD Compute the product of two images. [P, PMAX, PMIN, PN] = IMPROD(F, G) outputs the element-by-element product of two input images, F and G, the product maximum and minimum values, and a normalized product array with values in the range [0, 1]. The input images must be of the same size. They can be of class uint8, unit16, or double. The outputs are of class double. Sample M-file used in Chapter 2.

imratio.m

IMRATIO Computes the ratio of the bytes in two images/variables. CR = IMRATIO(F1, F2) returns the ratio of the number of bytes in variables/files F1 and F2. If F1 and F2 are an original and compressed image, respectively, CR is the compression ratio.

imstack2vectors.m

IMSTACK2VECTORS Extracts vectors from an image stack. [X, R] = imstack2vectors(S, MASK) extracts vectors from S, which is an M-by-N-by-n stack array of n registered images of size M-by-N each (see Fig. 12.29). The extracted vectors are arranged as the rows of array X. Input MASK is an M-by-N logical or numeric image with nonzero values (1s if it is a logical array) in the locations where elements of S are to be used in forming X and 0s in locations to be ignored. The number of row vectors in X is equal to the number of nonzero elements of MASK. If MASK is omitted, all M*N locations are used in forming X. A simple way to obtain MASK interactively is to use function roipoly. Finally, R is a column vector that contains the linear indices of the locations of the vectors extracted from S.

imtransform2.m

IMTRANSFORM2 2-D image transformation with fixed output location G = IMTRANSFORM2(F, TFORM, ...) applies a 2-D geometric transformation to an image. IMTRANSFORM2 fixes the output image location to cover the same region as the input image. IMTRANSFORM2 takes the same set of optional parameter/value pairs as IMTRANSFORM.

intline.m

INTLINE Integer-coordinate line drawing algorithm. [X, Y] = INTLINE(X1, X2, Y1, Y2) computes an approximation to the line segment joining (X1, Y1) and (X2, Y2) with integer coordinates. X1, X2, Y1, and Y2 should be integers. INTLINE is reversible; that is, INTLINE(X1, X2, Y1, Y2) produces the same results as FLIPUD(INTLINE(X2, X1, Y2, Y1)).

intrans.m

INTRANS Performs intensity (gray-level) transformations. G = INTRANS(F, 'neg') computes the negative of input image F. G = INTRANS(F, 'log', C, CLASS) computes C*log(1 + F) and multiplies the result by (positive) constant C. If the last two parameters are omitted, C defaults to 1. Because the log is used frequently to display Fourier spectra, parameter CLASS offers the option to specify the class of the output as 'uint8' or 'uint16'. If parameter CLASS is omitted, the output is of the same class as the input. G = INTRANS(F, 'gamma', GAM) performs a gamma transformation on the input image using parameter GAM (a required input). G = INTRANS(F, 'stretch', M, E) computes a contrast-stretching transformation using the expression 1./(1 + (M./F).^E). Parameter M must be in the range [0, 1]. The default value for M is mean2(tofloat(F)), and the default value for E is 4. G = INTRANS(F, 'specified', TXFUN) performs the intensity transformation s = TXFUN(r) where r are input intensities, s are output intensities, and TXFUN is an intensity transformation (mapping) function, expressed as a vector with values in the range [0, 1]. TXFUN must have at least two values. For the 'neg', 'gamma', 'stretch' and 'specified' transformations, floating-point input images whose values are outside the range [0, 1] are scaled first using MAT2GRAY. Other images are converted to floating point using TOFLOAT. For the 'log' transformation,floating-point images are transformed without being scaled; other images are converted to floating point first using TOFLOAT. The output is of the same class as the input, except if a different class is specified for the 'log' option.

invmoments.m

INVMOMENTS Compute invariant moments of image. PHI = INVMOMENTS(F) computes the moment invariants of the image F. PHI is a seven-element row vector containing the moment invariants as defined in equations (11.3-17) through (11.3-23) of Gonzalez and Woods, Digital Image Processing, 2nd Ed. F must be a 2-D, real, nonsparse, numeric or logical matrix.

iseven.m

ISEVEN Determines which elements of an array are even numbers. E = ISEVEN(A) returns a logical array, E, of the same size as A, with 1s (TRUE) in the locations corresponding to even numbers in A, and 0s (FALSE) elsewhere.

isodd.m

ISODD Determines which elements of an array are odd numbers. D = ISODD(A) returns a logical array, D, of the same size as A, with 1s (TRUE) in the locations corresponding to odd numbers in A, and 0s (FALSE) elsewhere.

jpeg2im.m

JPEG2IM Decodes an IM2JPEG compressed image. X = JPEG2IM(Y) decodes compressed image Y, generating reconstructed approximation X. Y is a structure generated by IM2JPEG. See also IM2JPEG.

jpeg2k2im.m

JPEG2K2IM Decodes an IM2JPEG2K compressed image. X = JPEG2K2IM(Y) decodes compressed image Y, reconstructing an approximation of the original image X. Y is an encoding structure returned by IM2JPEG2K. See also IM2JPEG2K.

lambdafcns.m

LAMBDAFCNS Lambda functions for a set of fuzzy rules. L = LAMBDAFCNS(INMF, OP) creates a set of lambda functions (rule strength functions) corresponding to a set of fuzzy rules. L is a cell array of function handles. INMF is an M-by-N matrix of input membership function handles. M is the number of rules, and N is the number of fuzzy system inputs. INMF(i, j) is the input membership function applied by the i-th rule to the j-th input. For example, in the case of Fig. 3.25, INMF would be of size 3-by-2 (three rules and two inputs). OP is a function handle used to combine the antecedents for each rule. OP can be either @min or @max. If omitted, the default value for OP is @min. The output lambda functions are called later with N inputs, Z1, Z2, ..., ZN, to determine rule strength: lambda_i = L{i}(Z1, Z2, ..., ZN)

localmean.m

LOCALMEAN Computes an array of local means. MEAN = LOCALMEAN(F, NHOOD) computes the mean at the center of every neighborhood of F defined by NHOOD, an array of zeros and ones where the nonzero elements specify the neighbors used in the computation of the local means. The size of NHOOD must be odd in each dimension; the default is ones(3). Output MEAN is an array the same size as F containing the local mean at each point.

localthresh.m

LOCALTHRESH Local thresholding. G = LOCALTHRESH(F, NHOOD, A, B, MEANTYPE) thresholds image F by computing a local threshold at the center,(x, y), of every neighborhood in F. The size of the neighborhoods is defined by NHOOD, an array of zeros and ones in which the nonzero elements specify the neighbors used in the computation of the local mean and standard deviation. The size of NHOOD must be odd in both dimensions. The segmented image is given by 1 if (F > A*SIG) AND (F > B*MEAN) G = 0 otherwise where SIG is an array of the same size as F containing the local standard deviations. If MEANTYPE = 'local' (the default), then MEAN is an array of local means. If MEANTYPE = 'global', then MEAN is the global (image) mean, a scalar. Constants A and B are nonnegative scalars.

lpc2mat.m

LPC2MAT Decompresses a 1-D lossless predictive encoded matrix. X = LPC2MAT(Y, F) decodes input matrix Y based on linear prediction coefficients in F and the assumption of 1-D lossless predictive coding. If F is omitted, filter F = 1 (for previous pixel coding) is assumed. See also MAT2LPC.

lpfilter.m

LPFILTER Computes frequency domain lowpass filters. H = LPFILTER(TYPE, M, N, D0, n) creates the transfer function of a lowpass filter, H, of the specified TYPE and size (M-by-N). To view the filter as an image or mesh plot, it should be centered using H = fftshift(H). Valid values for TYPE, D0, and n are: 'ideal' Ideal lowpass filter with cutoff frequency D0. n need not be supplied. D0 must be positive. 'btw' Butterworth lowpass filter of order n, and cutoff D0. The default value for n is 1.0. D0 must be positive. 'gaussian' Gaussian lowpass filter with cutoff (standard deviation) D0. n need not be supplied. D0 must be positive. H is of floating point class single. It is returned uncentered for consistency with filtering function dftfilt. To view H as an image or mesh plot, it should be centered using Hc = fftshift(H).

mahalanobis.m

MAHALANOBIS Computes the Mahalanobis distance. D = MAHALANOBIS(Y, X) computes the Mahalanobis distance between each vector in Y to the mean (centroid) of the vectors in X, and outputs the result in vector D, whose length is size(Y, 1). The vectors in X and Y are assumed to be organized as rows. The input data can be real or complex. The outputs are real quantities. D = MAHALANOBIS(Y, CX, MX) computes the Mahalanobis distance between each vector in Y and the given mean vector, MX. The results are output in vector D, whose length is size(Y, 1). The vectors in Y are assumed to be organized as the rows of this array. The input data can be real or complex. The outputs are real quantities. In addition to the mean vector MX, the covariance matrix CX of a population of vectors X must be provided also. Use function COVMATRIX (Section 12.5) to compute MX and CX.

makefuzzyedgesys.m

MAKEFUZZYEDGESYS Script to make MAT-file used by FUZZYFILT.

manualhist.m

MANUALHIST Generates a two-mode histogram interactively. P = MANUALHIST generates a two-mode histogram using function TWOMODEGAUSS(m1, sig1, m2, sig2, A1, A2, k). m1 and m2 are the means of the two modes and must be in the range [0,1]. sig1 and sig2 are the standard deviations of the two modes. A1 and A2 are amplitude values, and k is an offset value that raises the floor of the histogram. The number of elements in the histogram vector P is 256 and sum(P) is normalized to 1. MANUALHIST repeatedly prompts for the parameters and plots the resulting histogram until the user types an 'x' to quit, and then it returns the last histogram computed. A good set of starting values is: (0.15, 0.05, 0.75, 0.05, 1, 0.07, 0.002).

mat2huff.m

MAT2HUFF Huffman encodes a matrix. Y = MAT2HUFF(X) Huffman encodes matrix X using symbol probabilities in unit-width histogram bins between X's minimum and maximum values. The encoded data is returned as a structure Y: Y.code The Huffman-encoded values of X, stored in a uint16 vector. The other fields of Y contain additional decoding information, including: Y.min The minimum value of X plus 32768 Y.size The size of X Y.hist The histogram of X If X is logical, uint8, uint16, uint32, int8, int16, or double, with integer values, it can be input directly to MAT2HUFF. The minimum value of X must be representable as an int16. If X is double with non-integer values---for example, an image with values between 0 and 1---first scale X to an appropriate integer range before the call. For example, use Y = MAT2HUFF(255*X) for 256 gray level encoding. NOTE: The number of Huffman code words is round(max(X(:))) - round(min(X(:))) + 1. You may need to scale input X to generate codes of reasonable length. The maximum row or column dimension of X is 65535. See also HUFF2MAT.

mat2lpc.m

MAT2LPC Compresses a matrix using 1-D lossles predictive coding. Y = MAT2LPC(X, F) encodes matrix X using 1-D lossless predictive coding. A linear prediction of X is made based on the coefficients in F. If F is omitted, F = 1 (for previous pixel coding) is assumed. The prediction error is then computed and output as encoded matrix Y. See also LPC2MAT.

movie2tifs.m

MOVIE2TIFS Creates a multiframe TIFF file from a MATLAB movie. MOVIE2TIFS(M, FILE) creates a multiframe TIFF file from the specified MATLAB movie structure, M.

movingthresh.m

MOVINGTHRESH Image segmentation using a moving average threshold. G = MOVINGTHRESH(F, n, K) segments image F by thresholding its intensities based on the moving average of the intensities along individual rows of the image. The average at pixel k is formed by averaging the intensities of that pixel and its n - 1 preceding neighbors. To reduce shading bias, the scanning is done in a zig-zag manner, treating the pixels as if they were a 1-D, continuous stream. If the value of the image at a point exceeds K percent of the value of the running average at that point, a 1 is output in that location in G. Otherwise a 0 is output. At the end of the procedure, G is thus the thresholded (segmented) image. K must be a scalar in the range [0, 1].

ntrop.m

NTROP Computes a first-order estimate of the entropy of a matrix. H = NTROP(X, N) returns the entropy of matrix X with N symbols. N = 256 if omitted but it must be larger than the number of unique values in X for accurate results. The estimate assumes a statistically independent source characterized by the relative frequency of occurrence of the elements in X. The estimate is a lower bound on the average number of bits per unique value (or symbol) when coding without coding redundancy.

onemf.m

ONEMF Constant membership function (one). ONEMF(Z) returns an an array of ones with the same size as Z. When using the @min operator to combine rule antecedents, associating this membership function with a particular input means that input has no effect.

otsuthresh.m

OTSUTHRESH Otsu's optimum threshold given a histogram. [T, SM] = OTSUTHRESH(H) computes an optimum threshold, T, in the range [0 1] using Otsu's method for a given a histogram, H.

paddedsize.m

PADDEDSIZE Computes padded sizes useful for FFT-based filtering. PQ = PADDEDSIZE(AB), where AB is a two-element size vector, computes the two-element size vector PQ = 2*AB. PQ = PADDEDSIZE(AB, 'PWR2') computes the vector PQ such that PQ(1) = PQ(2) = 2^nextpow2(2*m), where m is MAX(AB). PQ = PADDEDSIZE(AB, CD), where AB and CD are two-element size vectors, computes the two-element size vector PQ. The elements of PQ are the smallest even integers greater than or equal to AB + CD - 1. PQ = PADDEDSIZE(AB, CD, 'PWR2') computes the vector PQ such that PQ(1) = PQ(2) = 2^nextpow2(2*m), where m is MAX([AB CD]).

percentile2i.m

PERCENTILE2I Computes an intensity value given a percentile. I = PERCENTILE2I(H, P) Given a percentile, P, and a histogram, H, this function computes an intensity, I, representing the Pth percentile and returns the value in I. P must be in the range [0, 1] and I is returned as a value in the range [0, 1] also. Example: Suppose that h is a uniform histogram of an 8-bit image. Typing I = percentile2i(h, 0.5) would output I = 0.5. To convert to the (integer) 8-bit range [0, 255], we let I = floor(255*I). See also function i2percentile.

pixeldup.m

PIXELDUP Duplicates pixels of an image in both directions. B = PIXELDUP(A, M, N) duplicates each pixel of A M times in the vertical direction and N times in the horizontal direction. Parameters M and N must be integers. If N is not included, it defaults to M.

pointgrid.m

POINTGRID Points arranged on a grid. WZ = POINTGRID(CORNERS) computes a set point of points on a grid containing 10 horizontal and vertical lines. Each line contains 50 points. CORNERS is a 2-by-2 matrix. The first row contains the horizontal and vertical coordinates of one corner of the grid. The second row contains the coordinates of the opposite corner. Each row of the P-by-2 output matrix, WZ, contains the coordinates of a point on the output grid.

polyangles.m

POLYANGLES Computes internal polygon angles. ANGLES = POLYANGLES(X, Y) computes the interior angles (in degrees) of an arbitrary polygon whose vertices are given in [X, Y], ordered in a clockwise manner. The program eliminates duplicate adjacent rows in [X Y], except that the first row may equal the last, so that the polygon is closed.

predicate.m

PREDICATE Evaluates a predicate for function splitmerge FLAG = PREDICATE(REGION) evaluates a predicate for use in function splitmerge for Example 11.14 in Digital Image Processing Using MATLAB, 2nd edition. REGION is a subimage, and FLAG is set to TRUE if the predicate evaluates to TRUE for REGION; FLAG is set to FALSE otherwise.

principalcomps.m

PRINCIPALCOMPS Principal-component vectors and related quantities. P = PRINCIPALCOMPS(X, Q) Computes the principal-component vectors of the vector population contained in the rows of X, a matrix of size K-by-n where K (assumed to be > 1)is the number of vectors and n is their dimensionality. Q, with values in the range [0, n], is the number of eigenvectors used in constructing the principal-components transformation matrix. P is a structure with the following fields: P.Y K-by-Q matrix whose columns are the principal- component vectors. P.A Q-by-n principal components transformation matrix whose rows are the Q eigenvectors of Cx corresponding to the Q largest eigenvalues. P.X K-by-n matrix whose rows are the vectors reconstructedfrom the principal-component vectors. P.X and P.Y are identical if Q = n. P.ems The mean square error incurred in using only the Q eigenvectors corresponding to the largest eigenvalues. P.ems is 0 if Q = n. P.Cx The n-by-n covariance matrix of the population in X. P.mx The n-by-1 mean vector of the population in X. P.Cy The Q-by-Q covariance matrix of the population in Y. The main diagonal contains the eigenvalues (in descending order) corresponding to the Q eigenvectors.

quantize.m

QUANTIZE Quantizes the elements of a UINT8 matrix. Y = QUANTIZE(X, B, TYPE) quantizes X to B bits. Truncation is used unless TYPE is 'igs' for Improved Gray Scale quantization.

randvertex.m

RANDVERTEX Adds random noise to the vertices of a polygon. [XN, YN] = RANDVERTEX[X, Y, NPIX] adds uniformly distributed noise to the coordinates of vertices of a polygon. The coordinates of the vertices are input in X and Y, and NPIX is the maximum number of pixel locations by which any pair (X(i), Y(i)) is allowed to deviate. For example, if NPIX = 1, the location of any X(i) will not deviate by more than one pixel location in the x-direction, and similarly for Y(i). Noise is added independently to the two coordinates.

recnotch.m

RECNOTCH Generates rectangular notch (axes) filters. H = RECNOTCH(NOTCH, MODE, M, N, W, SV, SH) generates an M-by-N notch filter consisting of symmetric pairs of rectangles of width W placed on the vertical and horizontal axes of the (centered) frequency rectangle. The vertical rectangles start at +SV and -SV on the vertical axis and extend to both ends of the axis. Horizontal rectangles similarly start at +SH and -SH and extend to both ends of the axis. These values are with respect to the origin of the axes of the centered frequency rectangle. For example, specifying SV = 50 creates a rectangle of width W that starts 50 pixels above the center of the vertical axis and extends up to the first row of the filter. A similar rectangle is created starting 50 pixels below the center and extending to the last row. W must be an odd number to preserve the symmetry of the filtered Fourier transform. Valid values of NOTCH are: 'reject' Notchreject filter. 'pass' Notchpass filter. Valid values of MODE are: 'both' Filtering on both axes. 'horizontal' Filtering on horizontal axis only. 'vertical' Filtering on vertical axis only. One of these three values must be specified in the call. H = RECNOTCH(NOTCH, MODE, M, N) sets W = 1, and SV = SH = 1. H is of floating point class single. It is returned uncentered for consistency with filtering function dftfilt. To view H as an image or mesh plot, it should be centered using Hc = fftshift(H).

regiongrow.m

REGIONGROW Perform segmentation by region growing. [G, NR, SI, TI] = REGIONGROW(F, S, T). S can be an array (the same size as F) with a 1 at the coordinates of every seed point and 0s elsewhere. S can also be a single seed value. Similarly, T can be an array (the same size as F) containing a threshold value for each pixel in F. T can also be a scalar, in which case it becomes a global threshold. All values in S and T must be in the range [0, 1] G is the result of region growing, with each region labeled by a different integer, NR is the number of regions, SI is the final seed image used by the algorithm, and TI is the image consisting of the pixels in F that satisfied the threshold test, but before they were processed for connectivity.

reprotate.m

REPROTATE Rotate image repeatedly G = REPROTATE(F, INTERP_METHOD) rotates the input image, F, twelve times in succession as a test of different interpolation methods. INTERP_METHOD can be one of the strings 'nearest', 'bilinear', or 'bicubic'.

rgb2hsi.m

RGB2HSI Converts an RGB image to HSI. HSI = RGB2HSI(RGB) converts an RGB image to HSI. The input image is assumed to be of size M-by-N-by-3, where the third dimension accounts for three image planes: red, green, and blue, in that order. If all RGB component images are equal, the HSI conversion is undefined. The input image can be of class double (with values in the range [0, 1]), uint8, or uint16. The output image, HSI, is of class double, where: HSI(:, :, 1) = hue image normalized to the range [0, 1] by dividing all angle values by 2*pi. HSI(:, :, 2) = saturation image, in the range [0, 1]. HSI(:, :, 3) = intensity image, in the range [0, 1].

rgbcube.m

RGBCUBE Displays an RGB cube on the MATLAB desktop. RGBCUBE(VX, VY, VZ) displays an RGB color cube, viewed from point (VX, VY, VZ). With no input arguments, RGBCUBE uses (10, 10, 4) as the default viewing coordinates. To view individual color planes, use the following viewing coordinates, where the first color in the sequence is the closest to the viewing axis, and the other colors are as seen from that axis, proceeding to the right right (or above), and then moving clockwise. ------------------------------------------------- COLOR PLANE ( vx, vy, vz) ------------------------------------------------- Blue-Magenta-White-Cyan ( 0, 0, 10) Red-Yellow-White-Magenta ( 10, 0, 0) Green-Cyan-White-Yellow ( 0, 10, 0) Black-Red-Magenta-Blue ( 0, -10, 0) Black-Blue-Cyan-Green (-10, 0, 0) Black-Red-Yellow-Green ( 0, 0, -10)

seq2tifs.m

SEQ2TIFS Creates a multi-frame TIFF file from a MATLAB sequence.

showmo.m

SHOWMO Displays the motion vectors of a compressed image sequence. SHOWMO(CV, I) displayes the motion vectors for frame I of a TIFS2CV compressed sequence of images. See also TIFS2CV and CV2TIFS.

sigmamf.m

SIGMAMF Sigma membership function. MU = SIGMAMF(Z, A, B) computes the sigma fuzzy membership function. Z is the input variable and can be a vector of any length. A and B are scalar shape parameters, ordered such that A <= B. MU = 0, Z < A MU = (Z - A) ./ (B - A), A <= Z < B MU = 1, B <= Z

signature.m

SIGNATURE Computes the signature of a boundary. [DIST, ANGLE, XC, YC] = SIGNATURE(B, X0, Y0) computes the signature of a given boundary. A signature is defined as the distance from (X0, Y0) to the boundary, as a function of angle (ANGLE). B is an np-by-2 array (np > 2) containing the (x, y) coordinates of the boundary ordered in a clockwise or counterclockwise direction. If (X0, Y0) is not included in the input argument, the centroid of the boundary is used by default. The maximum size of arrays DIST and ANGLE is 360-by-1, indicating a maximum resolution of one degree. The input must be a one-pixel-thick boundary obtained, for example, by using function bwboundaries. If (X0, Y0) or the default centroid is outside the boundary, the signature is not defined and an error is issued.

smf.m

SMF S-shaped membership function. MU = SMF(Z, A, B) computes the S-shaped fuzzy membership function. Z is the input variable and can be a vector of any length. A and B are scalar shape parameters, ordered such that A <= B. MU = 0, Z < A MU = 2*((Z - A) ./ (B - A)).^2, A <= Z < P MU = 1 - 2*((Z - B) ./ (B - A)).^2, P <= Z < B MU = 1, B <= Z where P = (A + B)/2.

specxture.m

SPECXTURE Computes spectral texture of an image. [SRAD, SANG, S] = SPECXTURE(F) computes SRAD, the spectral energy distribution as a function of radius from the center of the spectrum, SANG, the spectral energy distribution as a function of angle for 0 to 180 degrees in increments of 1 degree, and S = log(1 + spectrum of f), normalized to the range [0, 1]. The maximum value of radius is min(M,N), where M and N are the number of rows and columns of image (region) f. Thus, SRAD is a row vector of length = (min(M, N)/2) - 1; and SANG is a row vector of length 180.

spfilt.m

SPFILT Performs linear and nonlinear spatial filtering. F = SPFILT(G, TYPE, M, N, PARAMETER) performs spatial filtering of image G using a TYPE filter of size M-by-N. Valid calls to SPFILT are as follows: F = SPFILT(G, 'amean', M, N) Arithmetic mean filtering. F = SPFILT(G, 'gmean', M, N) Geometric mean filtering. F = SPFILT(G, 'hmean', M, N) Harmonic mean filtering. F = SPFILT(G, 'chmean', M, N, Q) Contraharmonic mean filtering of order Q. The default Q is 1.5. F = SPFILT(G, 'median', M, N) Median filtering. F = SPFILT(G, 'max', M, N) Max filtering. F = SPFILT(G, 'min', M, N) Min filtering. F = SPFILT(G, 'midpoint', M, N) Midpoint filtering. F = SPFILT(G, 'atrimmed', M, N, D) Alpha-trimmed mean filtering. Parameter D must be a nonnegative even integer; its default value is 2. The default values when only G and TYPE are input are M = N = 3, Q = 1.5, and D = 2.

splitmerge.m

SPLITMERGE Segment an image using a split-and-merge algorithm. G = SPLITMERGE(F, MINDIM, @PREDICATE) segments image F by using a split-and-merge approach based on quadtree decomposition. MINDIM (a nonnegative integer power of 2) specifies the minimum dimension of the quadtree regions (subimages) allowed. If necessary, the program pads the input image with zeros to the nearest square size that is an integer power of 2. This guarantees that the algorithm used in the quadtree decomposition will be able to split the image down to blocks of size 1-by-1. The result is cropped back to the original size of the input image. In the output, G, each connected region is labeled with a different integer. Note that in the function call we use @PREDICATE for the value of fun. PREDICATE is a a user-defined function. Its syntax is FLAG = PREDICATE(REGION) Must return TRUE if the pixels in REGION satisfy the predicate defined in the body of the function; otherwise, the value of FLAG must be FALSE. The following simple example of function PREDICATE is used in Example 11.14 of the book. It sets FLAG to TRUE if the intensities of the pixels in REGION have a standard deviation that exceeds 10, and their mean intensity is between 0 and 125. Otherwise FLAG is set to false. function flag = predicate(region) sd = std2(region); m = mean2(region); flag = (sd > 10) & (m > 0) & (m < 125);

statmoments.m

STATMOMENTS Computes statistical central moments of image histogram. [W, UNV] = STATMOMENTS(P, N) computes up to the Nth statistical central moment of a histogram whose components are in vector P. The length of P must equal 256 or 65536. The program outputs a vector V with V(1) = mean, V(2) = variance, V(3) = 3rd moment, . . . V(N) = Nth central moment. The random variable values are normalized to the range [0, 1], so all moments also are in this range. The program also outputs a vector UNV containing the same moments as V, but using un-normalized random variable values (e.g., 0 to 255 if length(P) = 2^8). For example, if length(P) = 256 and V(1) = 0.5, then UNV(1) would have the value UNV(1) = 127.5 (half of the [0 255] range).

statxture.m

STATXTURE Computes statistical measures of texture in an image. T = STATXURE(F, SCALE) computes six measures of texture from an image (region) F. Parameter SCALE is a 6-dim row vector whose elements multiply the 6 corresponding elements of T for scaling purposes. If SCALE is not provided it defaults to all 1s. The output T is 6-by-1 vector with the following elements: T(1) = Average gray level T(2) = Average contrast T(3) = Measure of smoothness T(4) = Third moment T(5) = Measure of uniformity T(6) = Entropy

strsimilarity.m

STRSIMILARITY Computes a similarity measure between two strings. R = STRSIMILARITY(A, B) computes the similarity measure, R, defined in Section 13.4.2 for strings A and B. The strings do not have to be of the same length, but only one of the strings can have blanks, and these must be trailing blanks. Blanks are not counted when computing the length of the strings for use in the similarity measure.

subim.m

SUBIM Extract subimage. S = SUBIM(F, M, N, RX, CY) extracts a subimage, S, from the input image, F. The subimage is of size M-by-N, and the coordinates of its top, left corner are (RX, CY). Sample M-file used in Chapter 2.

tifs2cv.m

TIFS2CV Compresses a multi-frame TIFF image sequence. Y = TIFS2CV(F, M, D, Q) compresses multiframe TIFF F using motion compensated frames, 8 x 8 DCT transforms, and Huffman coding. If parameter Q is omitted or is 0, only Huffman encoding is used and the compression is lossless; for Q > 0, lossy JPEG encoding is performed. The inputs are: F A multi-frame TIFF file (e.g., 'file.tif') M Macroblock size (e.g., 8) D Search displacement (e.g., [16 8]) Q JPEG quality for IM2JPEG (e.g., 1) Output Y is an encoding structure with fields: Y.blksz Size of motion compensation blocks Y.frames The number of frames in the image sequence Y.quality The reconstruction quality Y.motion Huffman encoded motion vectors Y.video An array of MAT2HUFF or IM2JPEG coding structures See also CV2TIFS.

tifs2movie.m

TIFS2MOVIE Create a MATLAB movie from a multiframe TIFF file. M = TIFS2MOVIE(FILE) creates a MATLAB movie structure from a multiframe TIFF file.

tifs2seq.m

TIFS2SEQ Create a MATLAB sequence from a multi-frame TIFF file.

timeit.m

TIMEIT Measure time required to run function. T = TIMEIT(F) measures the time (in seconds) required to run F, which is a function handle. TIMEIT handles automatically the usual benchmarking procedures of "warming up" F, figuring out how many times to repeat F in a timing loop, etc. TIMEIT also compensates for the estimated time-measurement overhead associated with tic/toc and with calling function handles. TIMEIT returns the median of several repeated measurements. If nargout(F) == 0, TIMEIT calls F with no output arguments, like this: F() If nargout(F) > 0, TIMEIT calls F with a single output argument, like this: OUT = F() If nargout(F) < 0, which can occur when F uses varargout or is an anonymous function, TIMEIT uses try/catch to determine whether to call F with one or zero output arguments. Examples -------- How much time does it take to compute sum(A.' .* B, 1), where A is 12000-by-400 and B is 400-by-12000? A = rand(12000, 400); B = rand(400, 12000); f = @() sum(A.' .* B, 1); timeit(f) How much time does it take to dilate the text.png image with a 25-by-25 all-ones structuring element? (This example uses Image Processing Toolbox functions.) bw = imread('text.png'); se = strel(ones(25, 25)); g = @() imdilate(bw, se); timeit(g)

tofloat.m

TOFLOAT Convert image to floating point [OUT, REVERTCLASS] = TOFLOAT(IN) converts the input image IN to floating-point. If IN is a double or single image, then OUT equals IN. Otherwise, OUT equals IM2SINGLE(IN). REVERTCLASS is a function handle that can be used to convert back to the class of IN.

trapezmf.m

TRAPEZMF Trapezoidal membership function. MU = TRAPEZMF(Z, A, B, C) computes a fuzzy membership function with a trapezoidal shape. Z is the input variable and can be a vector of any length. A, B, C, and D are scalar parameters that define the trapezoidal shape. The parameters must be ordered so that A <= B, B <= C, and C <= D. MU = 0, Z < A MU = (Z - A) ./ (B - A), A <= Z < B MU = 1, B <= Z < C MU = 1 - (Z - C) ./ (D - C), C <= Z < D MU = 0, D <= Z

triangmf.m

TRIANGMF Triangular membership function. MU = TRIANGMF(Z, A, B, C) computes a fuzzy membership function with a triangular shape. Z is the input variable and can be a vector of any length. A, B, and C are scalar parameters, such that B >= A and C >= B, that define the triangular shape. MU = 0, Z < A MU = (Z - A) ./ (B - A), A <= Z < B MU = 1 - (Z - B) ./ (C - B), B <= Z < C MU = 0, C <= Z

truncgaussmf.m

TRUNCGAUSSMF Truncated Gaussian membership function. MU = TRUNCGAUSSMF(Z, A, B, S) computes a truncated Gaussian fuzzy membership function. Z is the input variable and can be a vector of any length. A, B, and S are scalar shape parameters. A and B have to be ordered such that A <= B. MU = exp(-(Z - B).^2 / s^2), abs(Z - B) <= (B - A) MU = 0, otherwise

twodsin.m

TWODSIN Compare for-loops vs. vectorization. The comparison is based on implementing the function f(x, y) = Asin(u0x + v0y) for x = 0, 1, 2,..., M - 1 and y = 0, 1, 2,..., N - 1. The inputs to the function are M and N and the constants in the function. Sample M-file used in Chapter 2.

twomodegauss.m

TWOMODEGAUSS Generates a two-mode Gaussian function. P = TWOMODEGAUSS(M1, SIG1, M2, SIG2, A1, A2, K) generates a two-mode, Gaussian-like function in the interval [0, 1]. P is a 256-element vector normalized so that SUM(P) = 1. The mean and standard deviation of the modes are (M1, SIG1) and (M2, SIG2), respectively. A1 and A2 are the amplitude values of the two modes. Since the output is normalized, only the relative values of A1 and A2 are important. K is an offset value that raises the "floor" of the function. A good set of values to try is M1 = 0.15, SIG1 = 0.05, M2 = 0.75, SIG2 = 0.05, A1 = 1, A2 = 0.07, and K = 0.002.

unravel.m

UNRAVEL Decodes a variable-length bit stream. X = UNRAVEL(Y, LINK, XLEN) decodes UINT16 input vector Y based on transition and output table LINK. The elements of Y are considered to be a contiguous stream of encoded bits--i.e., the MSB of one element follows the LSB of the previous element. Input XLEN is the number code words in Y, and thus the size of output vector X (class DOUBLE). Input LINK is a transition and output table (that drives a series of binary searches): 1. LINK(0) is the entry point for decoding, i.e., state n = 0. 2. If LINK(n) < 0, the decoded output is |LINK(n)|; set n = 0. 3. If LINK(n) > 0, get the next encoded bit and transition to state [LINK(n) - 1] if the bit is 0, else LINK(n).

visreg.m

VISREG Visualize registered images VISREG(FREF, F, TFORM) displays two registered images together. FREF is the reference image. F is the input image, and TFORM defines the geometric transformation that aligns image F with image FREF. VISREG(FREF, F, TFORM, LAYER) displays F transparently over FREF if LAYER is 'top'; otherwise it displays FREF transparently over F. VISREG(FREF, F, TFORM, LAYER, ALPHA) uses the scalar value ALPHA, which ranges between 0.0 and 1.0, to control the level of transparency of the top image. If ALPHA is 1.0, the top image is opaque. If ALPHA is 0.0, the top image is invisible. H = VISREG(...) returns a vector of handles to the two displayed image objects. H is in the form [HBOTTOM, HTOP].

vistform.m

VISTFORM Visualization transformation effect on set of points. VISTFORM(TFORM, WZ) shows two plots. On the left are the points in each row of the P-by-2 matrix WZ. On the right are the spatially transformed points using TFORM.

wave2gray.m

WAVE2GRAY Display wavelet decomposition coefficients. W = WAVE2GRAY(C, S, SCALE, BORDER) displays and returns a wavelet coefficient image. EXAMPLES: wave2gray(c, s); Display w/defaults. foo = wave2gray(c, s); Display and return. foo = wave2gray(c, s, 4); Magnify the details. foo = wave2gray(c, s, -4); Magnify absolute values. foo = wave2gray(c, s, 1, 'append'); Keep border values. INPUTS/OUTPUTS: [C, S] is a wavelet decomposition vector and bookkeeping matrix. SCALE Detail coefficient scaling ---------------------------------------------------------- 0 or 1 Maximum range (default) 2,3... Magnify default by the scale factor -1, -2... Magnify absolute values by abs(scale) BORDER Border between wavelet decompositions ---------------------------------------------------------- 'absorb' Border replaces image (default) 'append' Border increases width of image Image W: ------- ------ ------------ ------------------- | | | | | a(n) | h(n) | | | | | | ------- ------ h(n-1) | | | | | | v(n) | d(n) | | h(n-2) | | | | ------- ------ ------------ | | | | v(n-1) | d(n-1) | | | | -------------- ------------ ------------------- | | | v(n-2) | d(n-2) | | Here, n denotes the decomposition step scale and a, h, v, d are approximation, horizontal, vertical, and diagonal detail coefficients, respectively.

waveback.m

WAVEBACK Computes inverse FWTs for multi-level decomposition [C, S]. [VARARGOUT] = WAVEBACK(C, S, VARARGIN) performs a 2D N-level partial or complete wavelet reconstruction of decomposition structure [C, S]. SYNTAX: Y = WAVEBACK(C, S, 'WNAME'); Output inverse FWT matrix Y Y = WAVEBACK(C, S, LR, HR); using lowpass and highpass reconstruction filters (LR and HR) or filters obtained by calling WAVEFILTER with 'WNAME'. [NC, NS] = WAVEBACK(C, S, 'WNAME', N); Output new wavelet [NC, NS] = WAVEBACK(C, S, LR, HR, N); decomposition structure [NC, NS] after N step reconstruction. See also WAVEFAST and WAVEFILTER.

wavecopy.m

WAVECOPY Fetches coefficients of a wavelet decomposition structure. Y = WAVECOPY(TYPE, C, S, N) returns a coefficient array based on TYPE and N. INPUTS: TYPE Coefficient category ------------------------------------- 'a' Approximation coefficients 'h' Horizontal details 'v' Vertical details 'd' Diagonal details [C, S] is a wavelet data structure. N specifies a decomposition level (ignored if TYPE = 'a'). See also WAVEWORK, WAVECUT, and WAVEPASTE.

wavecut.m

WAVECUT Zeroes coefficients in a wavelet decomposition structure. [NC, Y] = WAVECUT(TYPE, C, S, N) returns a new decomposition vector whose detail or approximation coefficients (based on TYPE and N) have been zeroed. The coefficients that were zeroed are returned in Y. INPUTS: TYPE Coefficient category ------------------------------------- 'a' Approximation coefficients 'h' Horizontal details 'v' Vertical details 'd' Diagonal details [C, S] is a wavelet data structure. N specifies a decomposition level (ignored if TYPE = 'a'). See also WAVEWORK, WAVECOPY, and WAVEPASTE.

wavedisplay.m

WAVEDISPLAY Display wavelet decomposition coefficients. W = WAVEDISPLAY(C, S, SCALE, BORDER) displays and returns a wavelet coefficient image. EXAMPLES: wavedisplay(c, s); Display w/defaults. foo = wavedisplay(c, s); Display and return. foo = wavedisplay(c, s, 4); Magnify the details. foo = wavedisplay(c, s, -4); Magnify absolute values. foo = wavedisplay(c, s, 1, 'append'); Keep border values. INPUTS/OUTPUTS: [C, S] is a wavelet decomposition vector and bookkeeping matrix. SCALE Detail coefficient scaling ---------------------------------------------------------- 0 or 1 Maximum range (default) 2,3... Magnify default by the scale factor -1, -2... Magnify absolute values by abs(scale) BORDER Border between wavelet decompositions ---------------------------------------------------------- 'absorb' Border replaces image (default) 'append' Border increases width of image Image W: ------- ------ ------------ ------------------- | | | | | a(n) | h(n) | | | | | | ------- ------ h(n-1) | | | | | | v(n) | d(n) | | h(n-2) | | | | ------- ------ ------------ | | | | v(n-1) | d(n-1) | | | | -------------- ------------ ------------------- | | | v(n-2) | d(n-2) | | Here, n denotes the decomposition step scale and a, h, v, d are approximation, horizontal, vertical, and diagonal detail coefficients, respectively.

wavefast.m

WAVEFAST Computes the FWT of a '3-D extended' 2-D array. [C, L] = WAVEFAST(X, N, LP, HP) computes 'PAGES' 2D N-level FWTs of a 'ROWS x COLUMNS x PAGES' matrix X with respect to decomposition filters LP and HP. [C, L] = WAVEFAST(X, N, WNAME) performs the same operation but fetches filters LP and HP for wavelet WNAME using WAVEFILTER. Scale parameter N must be less than or equal to log2 of the maximum image dimension. Filters LP and HP must be even. To reduce border distortion, X is symmetrically extended. That is, if X = [c1 c2 c3 ... cn] (in 1D), then its symmetric extension would be [... c3 c2 c1 c1 c2 c3 ... cn cn cn-1 cn-2 ...]. OUTPUTS: Vector C is a coefficient decomposition vector: C = [ a1(n)...ak(n) h1(n)...hk(n) v1(n)...vk(n) d1(n)...dk(n) h1(n-1)... d1(1)...dk(1) ] where ai, hi, vi, and di for i = 0,1,...k are columnwise vectors containing approximation, horizontal, vertical, and diagonal coefficient matrices, respectively, and k is the number of pages in the 3-D extended array X. C has 3n + 1 sections where n is the number of wavelet decompositions. Matrix S is an [(n+2) x 2] bookkeeping matrix if k = 1; else it is [(n+2) x 3]: S = [ sa(n, :); sd(n, :); sd(n-1, :); ... ; sd(1, :); sx ] where sa and sd are approximation and detail size entries. See also WAVEBACK and WAVEFILTER.

wavefilter.m

WAVEFILTER Create wavelet decomposition and reconstruction filters. [VARARGOUT] = WAVEFILTER(WNAME, TYPE) returns the decomposition and/or reconstruction filters used in the computation of the forward and inverse FWT (fast wavelet transform). EXAMPLES: [ld, hd, lr, hr] = wavefilter('haar') Get the low and highpass decomposition (ld, hd) and reconstruction (lr, hr) filters for wavelet 'haar'. [ld, hd] = wavefilter('haar','d') Get decomposition filters ld and hd. [lr, hr] = wavefilter('haar','r') Get reconstruction filters lr and hr. INPUTS: WNAME Wavelet Name --------------------------------------------------------- 'haar' or 'db1' Haar 'db4' 4th order Daubechies 'sym4' 4th order Symlets 'bior6.8' Cohen-Daubechies-Feauveau biorthogonal 'jpeg9.7' Antonini-Barlaud-Mathieu-Daubechies TYPE Filter Type --------------------------------------------------------- 'd' Decomposition filters 'r' Reconstruction filters See also WAVEFAST and WAVEBACK.

wavepaste.m

WAVEPASTE Puts coefficients in a wavelet decomposition structure. NC = WAVEPASTE(TYPE, C, S, N, X) returns the new decomposition structure after pasting X into it based on TYPE and N. INPUTS: TYPE Coefficient category ------------------------------------- 'a' Approximation coefficients 'h' Horizontal details 'v' Vertical details 'd' Diagonal details [C, S] is a wavelet data structure. N specifies a decomposition level (Ignored if TYPE = 'a'). X is a 2- or 3-D approximation or detail coefficient matrix whose dimensions are appropriate for decomposition level N. See also WAVEWORK, WAVECUT, and WAVECOPY.

wavework.m

WAVEWORK is used to edit wavelet decomposition structures. [VARARGOUT] = WAVEWORK(OPCODE, TYPE, C, S, N, X) gets the coefficients specified by TYPE and N for access or modification based on OPCODE. INPUTS: OPCODE Operation to perform -------------------------------------------------------------- 'copy' [varargout] = Y = requested (via TYPE and N) coefficient matrix 'cut' [varargout] = [NC, Y] = New decomposition vector (with requested coefficient matrix zeroed) AND requested coefficient matrix 'paste' [varargout] = [NC] = new decomposition vector with coefficient matrix replaced by X TYPE Coefficient category -------------------------------------------- 'a' Approximation coefficients 'h' Horizontal details 'v' Vertical details 'd' Diagonal details [C, S] is a wavelet toolbox decomposition structure. N is a decomposition level (Ignored if TYPE = 'a'). X is a 2- or 3-D coefficient matrix for pasting. See also WAVECUT, WAVECOPY, and WAVEPASTE.

wavezero.m

WAVEZERO Zeroes wavelet transform detail coefficients. [NC, G8] = WAVEZERO(C, S, L, WNAME) zeroes the level L detail coefficients in wavelet decomposition structure [C, S] and computes the resulting inverse transform with respect to WNAME wavelets.

x2majoraxis.m

X2MAJORAXIS Aligns coordinate x with the major axis of a region. [C, THETA] = X2MAJORAXIS(A, B) aligns the x-coordinate axis with the major axis of a region or boundary. The y-axis is perpendicular to the x-axis. The rows of 2-by-2 matrix A are the coordinates of the two end points of the major axis, in the form A = [x1 y1; x2 y2]. Input B is either a binary image (i.e., an array of class logical) containing a single region, or it is an np-by-2 set of points representing a (connected) boundary. In the latter case, the first column of B must represent x-coordinates and the second column must represent the corresponding y-coordinates. Output C contains the same data as the input, but aligned with the major axis. If the input is an image, so is the output; similarly the output is a sequence of coordinates if the input is such a sequence. Parameter THETA is the initial angle between the major axis and the x-axis. The origin of the xy-axis system is at the bottom left; the x-axis is the horizontal axis and the y-axis is the vertical. Keep in mind that rotations can introduce round-off errors when the data are converted to integer (pixel) coordinates, which typically is a requirement. Thus, postprocessing (e.g., with bwmorph) of the output may be required to reconnect a boundary.

zeromf.m

ZEROMF Constant membership function (zero). ZEROMF(Z) returns an an array of zeros with the same size as Z. When using the @max operator to combine rule antecedents, associating this membership function with a particular input means that input has no effect.

mgrep.m

mgrep: searches (recursively or not) files on a path for a given searchstring usage: mfilelist = mgrep(searchstring) usage: mfilelist = mgrep(searchstring,startpath) usage: mfilelist = mgrep(searchstring,startpath,prop1,val1,...) usage: mgrep searchstring usage: mgrep searchstring startpath usage: mgrep searchstring startpath prop1 val1 ... arguments: (input) searchstring - string - search string (no wildcards) startpath - (OPTIONAL) string - contains top level directory to search The search will not be recursive by default. If left empty or not supplied, then startpath will be the current directory. Additional arguments are in the form of property/value pairs. Properties may be in any order, and may be shortened as long as that shotening is unambiguous, down to a single letter. Capitalization is ignored. Valid properties: 'recurse', 'wholewords', 'casesens', 'showline') The only legal values for each of these properties are 'on' or 'off' 'recurse' - 'on' --> Recursively search subdirectories on the path 'off' --> Restrict search to only the specified directory DEFAULT = 'on' 'wholewords' - 'on' --> Find occurences of searchstring as a whole word 'off' --> Allow partial word matches DEFAULT = 'off' 'casesens' - 'on' --> Use case sensitive matches in the search 'off' --> Ignore case in the search DEFAULT = 'off' 'showline' - 'on' --> Include the line that contained each match 'off' --> Do not display the lines with matches DEFAULT = 'on' Arguments: (output) mfilelist - a cell array If no output argument is provided for, then the results of mgrep will only be displayed in the command window. This is the behavior of mgrep when used in command mode. Example usages: Recursive search, starting in the current directory for the string 'fmin', returning the result as a cell array. Any of these 3 alternatives will work: filelist = mgrep('fmin'); filelist = mgrep('fmin',pwd); filelist = mgrep('fmin','.'); Simple search of the directory './mylocaldir' for the string 'fmin', display the result in the command window. Do not search subdirectories. mgrep fmin ./mylocaldir recurse off Case sensitive search for the name "John D'Errico", through all subdirectories beginning with the current directory. Display the results in the command window. mgrep 'John DErrico' . c onMuch of this code is thanks to Brett Shoelson, Ph.D. My contribution was mainly the interface, plus any errors that may have surrepticiously appeared. John D'Errico, woodchips@rochester.rr.com