ToolBag file level help

From BanghamLab
Jump to navigation Jump to search

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 on


 Much 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