Toolboxes file level help
Jump to navigation
Jump to search
C:\Users\AB\DArT_Toolshed\Toolboxes\AreaFinder
AreaFinder.m
function AreaFinder Dr. A. I. Hanna, CMP, 2008
C:\Users\AB\DArT_Toolshed\Toolboxes\CellFinder
CellFinderTool.m
C:\Users\AB\DArT_Toolshed\Toolboxes\CellFinder\Images
C:\Users\AB\DArT_Toolshed\Toolboxes\CellFinder\SegmentationAlgorithms
cells_SEM.m
%%%%%%%%%%%%%%%%%%%% Process the cell image %%%%%%%%%%%%%%%%%%%%%
small_white_circles_on_black.m
%%%%%%%%%%%%%%%%%%%% Process the cell image %%%%%%%%%%%%%%%%%%%%%
stomata_stitched.m
%%%%%%%%%%%%%%%%%%%% Process the cell image %%%%%%%%%%%%%%%%%%%%%
C:\Users\AB\DArT_Toolshed\Toolboxes\CellSegment
cellSegment.m
gaussian3DBy1DFilter.m
function vol = gaussian3DBy1DFilter(f1d,numberOfTimes,display,halfwidth,halflength,halfheight,vol) f1d - a one dimensional filter numberOfTimes - number of times vol will be filtered with f1d display - flag set to 1 for debug display halfwidth,- only used for debugging default volumes set to 99 and ignore halflength,- only used for debugging default volumes set to 99 and ignore halfheight,- only used for debugging default volumes set to 99 and ignore vol optional - volume to be filtered (if not provided then it will use a default volume and return a 3D filter) filpdir - flag set to 1 to invert the filtered volume left to right Usage: filteredVolume = gaussian3DBy1DFilter(a1DFilter,1,0,99,99,99,volumeToBeFiltered,0);
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')
readTIFStack.m
A function that takes a string containing the name of a TIF stack, and returns a MxNxF volume where F is the number of images in the stack. Dr. A. I. Hanna (2007)
seedGaussFiller2d.m
need to tidy this function up, written on a plane with no sleep - % sorry...
seedGaussFiller2dVER2.m
need to tidy this function up, written on a plane with no sleep - % sorry...
seedGaussFiller3d.m
construct filler
seedGaussFiller3dVER2.m
construct filler
C:\Users\AB\DArT_Toolshed\Toolboxes\ClusterControl
getTheClusterNameAddress.m
function plain_pw=getTheClusterNameAddress(encrypted_pw)
encrypted_name, number array containing encrypted password
if there is no password file
you will be asked for your escluster.uea.ac.uk password
and an encrypted version will be stored in
the same directory as your DArT_Toolbox
It is stored in a file called 'growthpassword.mat'
plain_name, plain text version of password
J.Andrew Bangham, 2008
getpassword.m
function plain_pw=getpassword(encrypted_pw)
encrypted_pw, number array containing encrypted password
if there is no password file
you will be asked for your escluster.uea.ac.uk password
and an encrypted version will be stored in
the same directory as your DArT_Toolbox
It is stored in a file called 'growthpassword.mat'
plain_pw, plain text version of password
J.Andrew Bangham, 2008
getyourclusterdirectory.m
function plain_directory=getyourclustername(encrypted_directory)
encrypted_directory, number array containing encrypted directory
if there is no directory file
you will be asked for your escluster.uea.ac.uk directory
e.g. (A) is interpreted as gpfs_esscratch01/sys/
(B) is interpreted as gpfs_esscratch02/bio/
(C) specify the complete string e.g. gpfs_esscratch01/sys/
and an encrypted version will be stored in
the same directory as your DArT_Toolbox
It is stored in a file called 'growthpassword.mat'
plain_directory, plain text version of directory
J.Andrew Bangham, 2008
getyourclustername.m
function plain_pw=getyourclustername(encrypted_pw)
encrypted_name, number array containing encrypted password
if there is no password file
you will be asked for your escluster.uea.ac.uk password
and an encrypted version will be stored in
the same directory as your DArT_Toolbox
It is stored in a file called 'growthpassword.mat'
plain_name, plain text version of password
J.Andrew Bangham, 2008
getyouremail.m
function plain_pw=getyouremail(encrypted_name)
encrypted_name, number array containing encrypted email address
if there is no password file
you will be asked for your escluster.uea.ac.uk password
and an encrypted version will be stored in
the same directory as your DArT_Toolbox
It is stored in a file called 'growthpassword.mat'
plain_name, plain text version of password
J.Andrew Bangham, 2008
C:\Users\AB\DArT_Toolshed\Toolboxes\FilterTubulesExperiments
Bfillif.m
if nargin<1
arg='initialise';
end
if nargin<2
opt=[];
end
FillRidge.m
load fillridgedata
flood fill
counter=1;
loop over the seed points
push seed point
counter=counter+1;
while stack
pop
mark memoryimage with counter
look north/northeast etc.
if not already marked and most likely then push the index
end
endloop
PrepareImage.m
addtubulintoeb1.m
alterLFile.m
andrewToPaul.m
calcCatastrophies.m
velperum(length(collisionfiles)) = 0; velperumid(length(collisionfiles)) = 0; dyingprob(length(collisionfiles)) = 0;
calcdot.m
a = [1 1; 5 5] b = [3 3; 8 15] b = [1 1; 5 5]
chi.m
e = [0.25 0.25 0.25 0.25 0.25] x = [0 0 1 0 0] [sig chires] = chi(x,e)
collisionAnalyser.m
cropImage.m
crossFoldValidateKNN.m
dimsToUse = [2 3 4 5 6 7]
eb1speeds.m
fillif.m
filterToCell.m
A function for returning the tubules which intersect with the specified points. -path, a string containing the path to a dir containing tubule data (e.g /Users/JacobNewman/MyTubuleData2011/). -t, the time/frame to load from the data. t = 1 will load path/alltubules1.mat -xy, is a matrix where rows are samples the columns are x and y. These are the points we wish to check for tubules. -imXimY, is a two element vector where the first element is the length in x of the tubule image, and the second element is y. -tubules, is a structure returned upon executing this function. It contains data regarding the tubules that intersect with the specified xy-coords.
filterflow.m
findEnds.m
findTheBigOnes.m
findTubuleID.m
findseeds.m
fitGaussians.m
fitexample.m
floodfill.m
Jacob Newman 2011
followTubules.m
path = '/Users/jacobnewman/Desktop/DArT2/trunk/Toolboxes/FilterTubulesExperiments/28092011/'; outputpath = '/Users/jacobnewman/Desktop/DArT2/trunk/Toolboxes/FilterTubulesExperiments/28092011/2/';
followTubules2.m
formatForPaul.m
jakeTubules.m
A function for returning the tubules which intersect with the specified points. -path, a string containing the path to a dir containing tubule data (e.g /Users/JacobNewman/MyTubuleData2011/). -t, the time/frame to load from the data. t = 1 will load path/alltubules1.mat -xy, is a matrix where rows are samples the columns are x and y. These are the points we wish to check for tubules. -imXimY, is a two element vector where the first element is the length in x of the tubule image, and the second element is y. -tubules, is a structure returned upon executing this function. It contains data regarding the tubules that intersect with the specified xy-coords.
joinTubules.m
Input argument setup
labelRegions.m
makeArff.m
makeTestArff.m
img2;
makeTrainingMatFile.m
makeTrainingMatFile2.m
plot3DMTs.m
plotCompositeTubuleStats.m
queryTubules.m
queryTubulesStats.m
readScott.m
runDemo.m
Clear Matlab command window.
sammonFeatures.m
saveMask1D.m
Jacob Newman 2011
showAllCells.m
showstatic.m
sieve1d.m
skeleton.m
SKELETON produces skeletons of binary images [skg,rad] = skelgrad(img) computes the skeleton for a binary image, and also the local radius at each point.
statsPerLayer.m
steerGauss.m
STEERGAUSS Implements a steerable Gaussian filter.
This m-file can be used to evaluate the first
directional derivative of an image, using the
method outlined in:
W. T. Freeman and E. H. Adelson, "The Design
and Use of Steerable Filters", IEEE PAMI, 1991.
[J,H] = STEERGAUSE(I,THETA,SIGMA,VIS) evaluates
the directional derivative of the input image I,
oriented at THETA degrees with respect to the
image rows. The standard deviation of the Gaussian
kernel is given by SIGMA (assumed to be equal to
unity by default). The filter parameters are
returned to the user in the structure H.
[J,H] = STEERGAUSE(I,H,VIS) evaluates the
directional derivative of the input image I, using
the previously computed filter stored in H. Note
that H is a structure, with the following fields:
H.g: 1D Gaussian
H.gp: first-derivative of 1D Gaussian
H.theta: orientation of filter
H.sigma: standard derivation of Gaussian
Note that the filter support is automatically
adjusted (depending on the value of SIGMA).
In general, the visualization can be enabled
(or disabled) by setting VIS = TRUE (or FALSE).
By default, the visualization is disabled.
Author: Douglas R. Lanman, Brown University, Jan. 2006.
testAngles.m
testfillif.m
tubulesGUI.m
Jacob Newman 2011 Code for the findTubules_fig figure
velocityFig.m
wekaMatlab.m
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Boings
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\ExternalTools
check_menu_bar.m
VALUE = CHECK_MENU_BAR CHECK_MENU_BAR returns true if the integrated menu bar is DISABLED through a JAVA.OPTS file with "-Dapple.laf.useScreenMenuBar=false".
cvt_iterate.m
CVT_ITERATE takes one step of the CVT iteration.
Discussion:
The routine is given a set of points, called "generators", which
define a tessellation of the region into Voronoi cells. Each point
defines a cell. Each cell, in turn, has a centroid, but it is
unlikely that the centroid and the generator coincide.
Each time this CVT iteration is carried out, an attempt is made
to modify the generators in such a way that they are closer and
closer to being the centroids of the Voronoi cells they generate.
A large number of sample points are generated, and the nearest generator
is determined. A count is kept of how many points were nearest to each
generator. Once the sampling is completed, the location of all the
generators is adjusted. This step should decrease the discrepancy
between the generators and the centroids.
The centroidal Voronoi tessellation minimizes the "energy",
defined to be the integral, over the region, of the square of
the distance between each point in the region and its nearest generator.
The sampling technique supplies a discrete estimate of this
energy.
Modified:
19 November 2004
Author:
John Burkardt
Reference:
Qiang Du, Vance Faber, and Max Gunzburger,
Centroidal Voronoi Tessellations: Applications and Algorithms,
SIAM Review, Volume 41, 1999, pages 637-676.
Parameters:
Input, integer DIM_NUM, the spatial dimension.
Input, integer N, the number of Voronoi cells.
Input, integer BATCH, sets the maximum number of sample points
generated at one time. It is inefficient to generate the sample
points 1 at a time, but memory intensive to generate them all
at once. You might set BATCH to min ( SAMPLE_PER_GEN*N, 10000 ), for instance.
BATCH must be at least 1.
Input, integer SAMPLE, specifies how the sampling is done.
-1, 'RAND', using MATLAB's RAND function;
0, 'UNIFORM', using a simple uniform RNG;
1, 'HALTON', from a Halton sequence;
2, 'GRID', points from a grid;
3, 'USER', refers to the USER routine;
Input, logical INITIALIZE, is TRUE if the SEED must be reset to SEED_INIT
before computation. Also, the pseudorandom process may need to be
reinitialized.
Input, integer SAMPLE_PER_GEN, the number of sample points per generator.
Input, integer SEED, the random number seed.
Input, real R(DIM_NUM,N), the Voronoi cell generators.
Input, real AMOUNT, the proportion of distance towards the centroid to
move. 0 = no movement, 1 = original algorithm. Added by RK.
Input, string USERTYPE, and all subsequent arguments, extra
information to be supplied to user() (only used if SAMPLE==3).
Defaults to the empty string and no further arguments.
Added by RK 2006 Oct 02.
Output, real R(DIM_NUM,N), the updated Voronoi cell generators.
Output, integer SEED, the updated random number seed.
Output, real IT_DIFF, the L2 norm of the difference
between the iterates.
Output, real ENERGY, the discrete "energy", divided
by the number of sample points.
Output, real COUNT(N), the number of points in each cell.
Output, real CELLAXIS(N,DIM_NUM), the longest axis of each Voronoi
cell.
Output, real CENTROID(N,DIM_NUM), the centroid of each Voronoi
cell.
Output, real CELLEIGS(N,2), the maximum and minimum eigenvalues of
the covariance matrix of each Voronoi cell.
Output, real CELLCOV(N,DIM_NUM,DIM_NUM), the covariance matrix
of each Voronoi cell. (Not currently computed.)
cvt_sample.m
CVT_SAMPLE returns sample points.
Discussion:
N sample points are to be taken from the unit box of dimension DIM_NUM.
These sample points are usually created by a pseudorandom process
for which the points are essentially indexed by a quantity called
SEED. To get N sample points, we generate values with indices
SEED through SEED+N-1.
It may not be practical to generate all the sample points in a
single call. For that reason, the routine allows the user to
request a total of N points, but to require that only N_NOW be
generated now (on this call).
Modified:
23 June 2005
Author:
John Burkardt
Parameters:
Input, integer DIM_NUM, the spatial dimension.
Input, integer N, the number of sample points to be generated.
Input, integer N_NOW, the number of sample points to be generated
on this call. N_NOW must be at least 1.
Input, integer SAMPLE, specifies how the sampling is done.
-1, 'RAND', using MATLAB RAND function;
0, 'UNIFORM', using a simple uniform RNG;
1, 'HALTON', from a Halton sequence;
2, 'GRID', points from a grid;
3, 'USER', refer to USER routine.
Input, logical INITIALIZE, is TRUE if the pseudorandom process should be
reinitialized.
Input, integer SEED, the random number seed.
Input, struct USERDATA, extra information to be supplied to user()
(only used if SAMPLE==3). Defaults to the empty structure.
Added by RK 2006 Oct 02.
Output, real R(DIM_NUM,N_NOW), the initial value for the generators.
Output, integer SEED, the updated random number seed.
find_closest.m
FIND_CLOSEST finds the nearest R point to each S point.
Discussion:
This routine finds the closest Voronoi cell generator by checking every
one. For problems with many cells, this process can take the bulk
of the CPU time. Other approaches, which group the cell generators into
bins, can run faster by a large factor.
Modified:
22 October 2004
Author:
John Burkardt
Parameters:
Input, integer DIM_NUM, the spatial dimension.
Input, integer N, the number of cell generators.
Input, integer SAMPLE_NUM, the number of sample points.
Input, real S(DIM_NUM,SAMPLE_NUM), the points to be checked.
Input, real R(DIM_NUM,N), the cell generators.
Input, real W(N), weights associated with the cell generators.
Output, integer NEAREST(SAMPLE_NUM), the index of the nearest cell generators.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\ExternalTools\nearestneighbour
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\ExternalTools\nearestneighbour\demo
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\ExternalTools\nearestneighbour\demo\html
nndemo.m
NEARESTNEIGHBOUR Demonstration This (publishable) script |nndemo.m| demonstrates the features of the nearestneighbour function. Example: Open this file in an editor (in Matlab 7+) and press publish to generate the html document
Published output in the Help browser
showdemo nndemo
timingtest.m
TIMINGTEST Works out the average cputime required to run
nearestneighbour
This is a support function for nndemo.m
T = TIMINGTEST(P, X, MODE)
Runs NEARESTNEIGHBOUR(P, X, 'DelaunayMode', MODE) for at least one
second, and returns the average cputime for a single execution
Example
% A set of points
X = rand(2, 1000)
% A set of points to find the neighbours of
P = rand(2, 100)
% Compute the time to run with DelaunayMode 'on'
timingtest(P, X, 'on')
nearestneighbour.m
NEARESTNEIGHBOUR find nearest neighbours
IDX = NEARESTNEIGHBOUR(X) finds the nearest neighbour by Euclidean
distance to each point (column) in X from X. X is a matrix with points
as columns. IDX is a vector of indices into X, such that X(:, IDX) are
the nearest neighbours to X. e.g. the nearest neighbour to X(:, 2) is
X(:, IDX(2))
IDX = NEARESTNEIGHBOUR(P, X) finds the nearest neighbour by Euclidean
distance to each point in P from X. P and X are both matrices with the
same number of rows, and points are the columns of the matrices. Output
is a vector of indices into X such that X(:, IDX) are the nearest
neighbours to P
IDX = NEARESTNEIGHBOUR(I, X) where I is a logical vector or vector of
indices, and X has at least two rows, finds the nearest neighbour in X
to each of the points X(:, I).
I must be a row vector to distinguish it from a single point.
If X has only one row, the first input is treated as a set of 1D points
rather than a vector of indices
IDX = NEARESTNEIGHBOUR(..., Property, Value)
Calls NEARESTNEIGHBOUR with the indicated parameters set. Property
names can be supplied as just the first letters of the property name if
this is unambiguous, e.g. NEARESTNEIGHBOUR(..., 'num', 5) is equivalent
to NEARESTNEIGHBOUR(..., 'NumberOfNeighbours', 5). Properties are case
insensitive, and are as follows:
Property: Value:
--------- ------
NumberOfNeighbours natural number, default 1
NEARESTNEIGHBOUR(..., 'NumberOfNeighbours', K) finds the closest
K points in ascending order to each point, rather than the
closest point. If Radius is specified and there are not
sufficient numbers, fewer than K neighbours may be returned
Radius positive, default +inf
NEARESTNEIGHBOUR(..., 'Radius', R) finds neighbours within
radius R. If NumberOfNeighbours is not set, it will find all
neighbours within R, otherwise it will find at most
NumberOfNeighbours. The IDX matrix is padded with zeros if not
all points have the same number of neighbours returned. Note
that specifying a radius means that the Delaunay method will
not be used.
DelaunayMode {'on', 'off', |'auto'|}
DelaunayMode being set to 'on' means NEARESTNEIGHBOUR uses the
a Delaunay triangulation with dsearchn to find the points, if
possible. Setting it to 'auto' means NEARESTNEIGHBOUR decides
whether to use the triangulation, based on efficiency. Note
that the Delaunay triangulation will not be used if a radius
is specified.
Triangulation Valid triangulation produced by
delaunay or delaunayn
If a triangulation is supplied, NEARESTNEIGHBOUR will attempt
to use it (in conjunction with dsearchn) to find the
neighbours.
[IDX, TRI] = NEARESTNEIGHBOUR( ... )
If the Delaunay Triangulation is used, TRI is the triangulation of X'.
Otherwise, TRI is an empty matrix
Example:
% Find the nearest neighbour in X to each column of X
x = rand(2, 10);
idx = nearestneighbour(x);
% Find the nearest neighbours to each point in p
p = rand(2, 5);
x = rand(2, 20);
idx = nearestneighbour(p, x)
% Find the five nearest neighbours to points x(:, [1 6 20]) in x
x = rand(4, 1000)
idx = nearestneighbour([1 6 20], x, 'NumberOfNeighbours', 5)
% Find all neighbours within radius of 0.1 of the points in p
p = rand(2, 10);
x = rand(2, 100);
idx = nearestneighbour(p, x, 'r', 0.1)
% Find at most 10 nearest neighbours to point p from x within a
% radius of 0.2
p = rand(1, 2);
x = rand(2, 30);
idx = nearestneighbour(p, x, 'n', 10, 'r', 0.2)
See also DELAUNAYN, DSEARCHN, TSEARCH
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.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\ExternalTools\uiinspect
uiinspect.m
uiinspect Inspect an object handle (Java/COM/HG) and display its methods/props/callbacks in a unified window
Syntax:
hFig = uiinspect(obj, hFig) % hFig input argument is optional
Description:
UIINSPECT(OBJ) inspects an object handle (e.g., Java, COM, Handle
Graphics, Matlab class etc.) and displays inspection results in a
Matlab figure window with all the relevant object methods (as can be
displayed via Matlab's methodsview function), properties (as can be
displayed via Matlab's inspect function), static fields and callbacks.
UIINSPECT also displays properties that are not normally displayed
with Matlab's inspect function. Property meta-data such as type,
accessibility, visibility and default value are also displayed (where
available).
If the inspected object is an HG handle, then a component tree is
displayed instead of the methods pane (see attached animated screenshot).
Unlike Matlab's inspect function, multiple UIINSPECT windows can be
opened simultaneously.
Object properties and callbacks may be modified interactively within
the UIINSPECT window.
UIINSPECT(OBJ) reuses an already-displayed UIINSPECT window if its
title is the same (i.e., same object or class); otherwise a new window
is created. UIINPECT(OBJ,hFIG) forces using the specified hFig window
handle, even if another window would otherwise have been reused/created.
hFig = UIINSPECT(...) returns a handle to the UIINSPECT figure window.
UIINSPECT creates a regular Matlab figure window which may be accessed
via this hFig handle (unlike Matlab's methodsview function which opens
a Java frame that is not easily accessible from Matlab).
Examples:
hFig = uiinspect(0); % root (desktop)
hFig = uiinspect(handle(0)); % root handle
hFig = uiinspect(gcf); % current figure
uiinspect(get(gcf,'JavaFrame')); % current figure's Java Frame
uiinspect(classhandle(handle(gcf))); % a schema.class object
uiinspect(findprop(handle(gcf),'MenuBar')); % a schema.prop object
uiinspect('java.lang.String'); % a Java class name
uiinspect(java.lang.String('yes')); % a Java object
uiinspect(actxserver('Excel.Application')); % a COM object
uiinspect(Employee) % a Matlab class object
uiinspect(?handle) % a Matlab metaclass object
uiinspect('meta.class') % a Matlab class name
uiinspect(System.Diagnostics.Process.GetCurrentProcess) % a .Net object
Known issues/limitations:
- Fix: some fields generate a Java Exception, or a Matlab warning
- other future enhancements may be found in the TODO list below
Warning:
This code heavily relies on undocumented and unsupported Matlab functionality.
It works on Matlab 7+, but use at your own risk!
Bugs and suggestions:
Please send to Yair Altman (altmany at gmail dot com)
Change log:
2011-03-03: Fixed several issues in the Value field of the "Other properties" table
2011-02-28: Removed R2010b warning messages; minor fix for Dot-Net classes
2010-11-02: Minor fixes for callbacks table; fixed online docpage for Swing classes
2010-11-01: Major fix for pre-R2010 compatibility
2010-10-20: Minor fix suggested by Andrew Stamps; added automatic callbacks grouping
2010-06-13: Fixed download (m-file => zip-file)
2010-06-11: Displayed class modifiers; improved performance; removed empty panels by default; fixed warning msgs when sorting props table; fixes for R2010b
2010-03-18: Minor fix in copy-handle-value-to-clipboard (in tree context-menu)
2010-03-17: Fixes for R2010a
2010-01-16: Fixed a few bugs in properties meta-info of Matlab classes
2009-10-23: Added CaretPositionChanged & InputMethodTextChanged to list of standard callbacks; minor fix to requesting focus of Java handles; minor fix to version-check display
2009-05-22: Added support for Matlab classes (helped by Darik Gamble); improved display for classname input
2009-05-20: Fixed methods info gathering for some handles
2009-05-19: Improved information display for HG handles; added HG-handle screenshot to animated gif (added to COM, Java screenshots); enabled reuse of uiinspect window
2009-05-04: Fixed setting callbacks on non-handle('CallbackProperties')ed Java objects; fixed input param edge-case; hyperlinked the className to Sun's Javadocs where relevant; auto-checked newer version; removed main menu
2009-04-16: Fixed occasional endless loop upon callback update error
2009-04-01: Fixed case of no methods (e.g., uimenus); fixed superclass/interfaces of classname input; auto-hide callbacks pane if no CBs are available
2009-03-30: Added Extra method details checkbox (default=off); auto-hide inspectable checkbox if irrelevant; auto-sort methods by args list; hyperlinked classes; fixed title for classname inputs
2009-03-14: Fixed string property value displayed; fixed display of Java classes added to the dynamic classpath; fixed display of classname static fields value; updated list of standard callbacks
2009-03-05: Fixed single property edge-case; fixed prop name case sensitivity problem; fixed properties tooltip; accept class names; added display of class interfaces & static fields
2008-01-25: Fixes for many edge-cases
2007-12-08: 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:
ishandle, iscom, inspect, methodsview, FindJObj (on the File Exchange)
user.m
USER samples points in a user-specified region with given density.
Discussion:
This routine can be used to
* specify an interesting initial configuration for the data,
by specifing that USER be used for initialization (INIT = 3);
* specify the shape of the computational region, by specifying
that sample points are to be generated by this routine,
(SAMPLE = 3) and then returning sample points uniformly at random.
* specify the distribution or density function, by specifying
that sample points are to be generated by this routine,
(SAMPLE = 3 ) and then returning sample points according to a
given probability density function.
Author:
John Burkardt
Modified:
23 June 2005
Parameters:
Input, integer DIM_NUM, the spatial dimension.
Input, integer N, the number of sample points desired.
Input, integer SEED, a seed for the random number generator.
Input, string USERTYPE, specifying what sort of user data are supplied.
Input, struct USERDATA, user data.
Output, real R(DIM_NUM,N), a set of N sample values.
Output, integer SEED, the updated seed.
GFtbox.m
GFTBOX M-file for GFtbox.fig
GFTBOX, by itself, creates a new GFTBOX or raises the existing
singleton*.
H = GFTBOX returns the handle to a new GFTBOX or the handle to
the existing singleton*.
GFTBOX('CALLBACK',hObject,eventData,handles,...) calls the local
function named CALLBACK in GFTBOX.M with the given input arguments.
GFTBOX('Property','Value',...) creates a new GFTBOX or raises the
existing singleton*. Starting from the left, property value pairs are
applied to the GUI before GFtbox_OpeningFunction gets called. An
unrecognized property name or invalid value makes property application
stop. All inputs are passed to GFtbox_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
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Help
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\IFtemplates
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Icons
InitGFtboxPath.m
InitGFtboxPath() Call this if you have never run GFtbox before. It will add all of the GFtbox directories to your command path. You must be in the main GFtbox directory when you give this command. This command only affects the path for the current Matlab session. If you want to have the GFtbox directories on the command path permanently, then use the SAVEPATH command to save the current path. This will avoid having to use the INITGFTBOX command again. It is harmless, but unnecessary, to give this command if the GFtbox directories are already on your command path.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Green-etal-2010
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Green-etal-2010\GPT_Snapdragon_2010_Green_et_al
gpt_snapdragon_2010_green_et_al.m
m = gpt_snapdragon_2010_green_et_al( m ) Morphogen interaction function. Written at 2011-04-29 13:52:19. GFtbox revision 3502, 2011-04-15 16:29:35.777989. Model last saved to SVN as revision 1779, 2009-10-02 11:46:19.097914.
gpt_snapdragon_2010_green_et_alBAK.m
m = gpt_snapdragon_2010_green_et_al( m ) Morphogen interaction function. Written at 2011-04-29 13:52:19. GFtbox revision 3502, 2011-04-15 16:29:35.777989. Model last saved to SVN as revision 1779, 2009-10-02 11:46:19.097914.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Green-etal-2010\GPT_Snapdragon_2010_Green_et_al\snapshots
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASES_FGHI
gpt_cases_fghi.m
m = gpt_cases_fghi( m ) Morphogen interaction function. Written at 2011-04-19 15:43:11. GFtbox revision 3499, 2011-04-15 16:29:35.777989.
gpt_cases_fghiBAK.m
m = gpt_cases_fghi( m ) Morphogen interaction function. Written at 2011-04-19 15:43:11. GFtbox revision 3499, 2011-04-15 16:29:35.777989.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASES_FGHI\snapshots
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASES_JKLM
gpt_cases_jklm.m
m = gpt_cases_jklm( m ) Morphogen interaction function. Written at 2011-04-29 15:09:39. GFtbox revision 3518, 2011-04-29 13:30:15.502745.
gpt_cases_jklmBAK.m
m = gpt_cases_jklm( m ) Morphogen interaction function. Written at 2011-04-29 15:09:39. GFtbox revision 3518, 2011-04-29 13:30:15.502745.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASES_JKLM\snapshots
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASES_NOPQ
gpt_cases_nopq.m
m = gpt_cases_nopq( m ) Morphogen interaction function. Written at 2011-04-29 15:17:15. GFtbox revision 3518, 2011-04-29 13:30:15.502745.
gpt_cases_nopqBAK.m
m = gpt_cases_nopq( m ) Morphogen interaction function. Written at 2011-04-29 15:17:15. GFtbox revision 3518, 2011-04-29 13:30:15.502745.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASES_NOPQ\snapshots
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASE_A
gpt_case_a.m
m = gpt_case_a( m ) Morphogen interaction function. Written at 2011-04-29 14:44:45. GFtbox revision 3502, 2011-04-15 16:29:35.777989.
gpt_case_aBAK.m
m = gpt_case_a( m ) Morphogen interaction function. Written at 2011-04-29 14:44:45. GFtbox revision 3502, 2011-04-15 16:29:35.777989.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASE_A\snapshots
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASE_B
gpt_case_b.m
m = gpt_case_b( m ) Morphogen interaction function. Written at 2011-04-29 14:45:32. GFtbox revision 3502, 2011-04-15 16:29:35.777989.
gpt_case_bBAK.m
m = gpt_case_b( m ) Morphogen interaction function. Written at 2011-04-29 14:45:32. GFtbox revision 3502, 2011-04-15 16:29:35.777989.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASE_B\snapshots
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASE_C
gpt_case_c.m
m = gpt_case_c( m ) Morphogen interaction function. Written at 2011-04-29 14:57:50. GFtbox revision 3518, 2011-04-29 13:30:15.502745.
gpt_case_cBAK.m
m = gpt_case_c( m ) Morphogen interaction function. Written at 2011-04-29 14:57:50. GFtbox revision 3518, 2011-04-29 13:30:15.502745.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASE_C\snapshots
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASE_E
gpt_case_e.m
m = gpt_case_e( m ) Morphogen interaction function. Written at 2011-04-29 14:59:28. GFtbox revision 3518, 2011-04-29 13:30:15.502745.
gpt_case_eBAK.m
m = gpt_case_e( m ) Morphogen interaction function. Written at 2011-04-29 14:59:28. GFtbox revision 3518, 2011-04-29 13:30:15.502745.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASE_E\snapshots
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASE_RST
gpt_case_rst.m
m = gpt_case_rst( m ) Morphogen interaction function. Written at 2011-04-28 21:20:35. GFtbox revision 3517, 2011-04-27 08:05:05.157080.
gpt_case_rstBAK.m
m = gpt_case_rst( m ) Morphogen interaction function. Written at 2011-04-28 21:20:35. GFtbox revision 3517, 2011-04-27 08:05:05.157080.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_CASE_RST\snapshots
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_InvagEmbryo
gpt_invagembryo.m
m = gpt_invagembryo( m ) Morphogen interaction function. Written at 2011-04-28 13:51:14. GFtbox revision 3502, 2011-04-15 16:29:35.777989.
gpt_invagembryoBAK.m
m = gpt_invagembryo( m ) Morphogen interaction function. Written at 2011-04-28 13:51:14. GFtbox revision 3502, 2011-04-15 16:29:35.777989.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Published\Kennaway-etal-2011\GPT_InvagEmbryo\snapshots
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Models\Tutorial
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Utils
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Utils\Colour
brighten.m
combinedOpacity.m
darken.m
desaturate.m
nzimage.m
nzimage( A, blockx, blocky, f ) Produce a greyscale image showing the non-zero elements of A. Each pixel of im corresponds to a blockx*blocky tile of A, and its greyscale level represents the proportion of non-zero elements in that tile. f is a figure to plot into.
oppositeColor.m
c = oppositeColor( c, mode ) Compute a modified version of the colour complement of c (an N*3 matrix of RGB values). If 'mode' is 'redblue' (the default) then red and blue are opposites, as are green and magenta. If 'mode is 'redgreen', red and green are opposites, as are orange and blue, and yellow and magenta. Otherwise (the default), the standard inversion of hue is performed, i.e. red <-> cyan, green <-> magenta, and blue <-> yellow.
randcolornear.m
crange = randcolornear( numcolors, color, colorvariation ) Generate NUMCOLORS random colors that are "near" the given COLOR. If COLORVARIATION is 0, they will be equal to COLOR, while of COLORVARIATION is 1, they will be scattered over the whole colour space.
redBlueComplement.m
c = redBlueComplement( c ) Compute a modified version of the colour complement of c (an N*3 matrix of RGB values). If 'mode' is 'redblue' (the default) then red and blue are opposites, as are green and magenta. If 'mode is 'redgreen', red and green are opposites, as are orange and blue, and yellow and magenta. Otherwise (the default), the standard inversion of hue is performed, i.e. red <-> cyan, green <-> magenta, and blue <-> yellow.
saturate.m
c1 = saturate( v, c ) c is an RGB colour. v is a vector of N reals. The results is an N*3 array of N colours, being copies of c saturated by each element of v. Where v is 0, the colour is [1,1,1] (white), and where v is 1, the colour is c, with linear interpolation between. There is no check that v or c are within the range 0..1
translateToColors.m
c = translateToColors( v, crange, cmap ) Given a vector of values v, and range vrange = [lo,hi], and a list of colours, map every element of v to the corresponding colour. v is N*1, and c is N*3.
unspreadHue.m
h = unspreadHue( h, alph ) The inverse of h = spreadHue( h, alph )
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Utils\Geometry
aabbox.m
ab = aabbox( pts ) Return the axis-aligned bounding box of a set of points. pts is an N*K array of N K-dimensional points. The result is a 2*K array: a(1,:) is the minimum values of the coordinates and ab(2,:) the maximum values.
aabboxsize.m
absize = aabboxsize( pts ) Return the size of the axis-aligned bounding box of a set of points. pts is an N*K array of N K-dimensional points. The result is a 2*K array: a(1,:) is the minimum values of the coordinates and ab(2,:) the maximum values.
abutRect.m
r1 = abutRect( r, positioning, distance, thickness, len ) Create a rectangle r1 abutting r on the outside according to the other parameters. POSITIONING is a two-character string, with the second character defaulting to 'c'. The first is 'n', 's', 'w', or 'e' and specifies which side the new rectangle abuts the old. The second is 'n', 's', 'w', 'e', or 'c', and indicates which end of the abutted side r1 lines up with. For example, 'nw' abuts the new rectangle on the top edge of the old one, flush with its left-hand edge. DISTANCE is the space between r and r1. THICKNESS is the width of r1 in the direction in which it abuts r, and LEN is the width in the transverse direction. LEN can be omitted and defaults to the corresponding dimension of r, in which case the result is independent of the second character of POSITIONING.
alignFrames.m
perm = alignFrames( F1, F2 ) F1 and F2 are orthonormal frames of column vectors. The result is the permutation that makes F2(:,perm) most closely approximate F1. It first determines the column of F2 that F1(:,3) is closest to, then decides the order of the other two.
altitude.m
d = altitude( vxs, p ) Find the altitude of a point from a line segment. VXS is a 3*2 vector containing the ends of the segment.
altitudeTriangle.m
[a,alt,foot] = altitudeTriangle( vxs ) Compute the altitude of the triangle VXS, whose rows are the vertexes, through the first vertex. ALT is the altitude vector from the base towards that vertex, FOOT is the foot of the altitude, and A is the proportion into which it divides the base: FOOT = (1-A)*V(2,:) + A*V(3,:).
altitudeTriangle2D.m
[a,alt,foot] = altitudeTriangle2D( vxs ) Compute the altitude of the triangle VXS, whose rows are the vertexes, through the first vertex. ALT is the altitude vector from the base towards that vertex, FOOT is the foot of the altitude, and A is the proportion into which it divides the base: FOOT = (1-A)*V(2,:) + A*V(3,:). POSITIVE is true if the triangle is right-handed.
altitudeVector.m
a = altitudeVector( vxs, p ) Find the altitude vector from a line segment to a point. VXS is a 3*2 vector containing the ends of the segment.
azel2dir.m
d = azel2dir( az, el ) Convert azimuth and elevation, in degrees, to a unit vector. Azimuth and elevation have the meanings given to them by the Matlab function [az,el] = view(). That is, when the azimuth of the view is zero, the positive Y axis points into the screen. When the azimuth is 90, the negative X axis points into the screen. When elevation is zero, the positive Z axis points up the screen. When elevation is positive, the positive Z axis points upwards and out from the screen. When elevation is 90, the positive z axis points directly out of the screen. See also: dir2azel.
baryCoords.m
bc = baryCoords( vxs, n, v ) Calculate the barycentric coordinates of point v with respect to triangle vxs, in three dimensions. vxs contains the three vertexes of the triangle as rows. n is a normal vector to the triangle. The component of v perpendicular to the plane of the triangle is ignored. If n is the empty array, the normal vector will be computed. If supplied, the normal vector may be of any non-zero length. n and v must be row vectors, and the result is a 3-element row vector. v can also be a matrix of row vectors; the result will then be a matrix of 3-element row vectors. This procedure works in 3 or more dimensions. For 2 dimensions, use baryCoordsPlanar( vxs, v ).
baryCoords2.m
bc2 = baryCoords2( v1, v2, v ) Set bc2 to [a,b], where a+b = 1 and v = a*v1 + b*v2. v1, v2, and v must be row vectors, and the result is a 2-element row vector. v can be a matrix of row vectors; the result will then be a matrix of 2-element row vectors. v1 and v2 must be distinct. A divide by zero error will result if not. v is assumed to be collinear with v1 and v2, but no check is made and no errors are produced. The resulting values a and b will always satisfy a+b = 1. If v is not collinear with v1 and v2, the point a*v1 + b*v2 will be the closest point to v on the line through v1 and v2. This procedure works in any number of dimensions.
baryCoordsPlanar.m
bc = baryCoords( vxs, v ) Calculate the barycentric coordinates of point v with respect to triangle vxs, in two dimensions. vxs contains the three vertexes of the triangle as rows. v must be a row vector, and the result is a 3-element row vector. v can also be a matrix of row vectors; the result will then be a matrix of 3-element row vectors.
baryCoordsPlane.m
bc = baryCoords( vxs, v ) Calculate the barycentric coordinates of point v with respect to triangle vxs, in two dimensions. vxs contains the three vertexes of the triangle as rows. The component of v perpendicular to the plane of the triangle is ignored. If n is the empty array, the normal vector will be computed. If supplied, the normal vector may be of any non-zero length. n and v must be row vectors, and the result is a 3-element row vector. v can also be a matrix of row vectors; the result will then be a matrix of 3-element row vectors. This procedure works in 3 or more dimensions. For 2 dimensions, use baryCoordsPlanar( vxs, v ).
baryToEdge.m
bc = baryToEdge( bc ) Move the barycentric coordinate to the nearest edge, by replacing the component with minimum absolute value by zero and renormalising.
baryToGlobalCoords.m
gc = baryToGlobalCoords( cells, bcs, nodes, triangles )
Convert barycentric coordinates to global coordinates.
NODES is an N*D matrix containing the global coordinates of a set of N
points in D dimensions.
TRIANGLES is an M*3 matrix containing the indexes of triples of nodes.
CELLS is a C*1 or 1*C vector of indexes of triangles.
BCS is a C*3 array of barycentric coordinates. bcs(i,:) is the
barycentric coordinates of a point in the triangle cells(i).
The result is a C*D array of global coordinates of all the given
points.
See also GLOBALTOBARYCOORDS.
Timing tests:
3.2 microseconds per point, for 100 points.
4 microseconds per point for 10 points.
20 microseconds per point for 1 point.
baryVector2.m
bc = baryVector2( vxs, v ) Express the vector v in terms of the three 2D row vectors in vxs, as a linear combination adding to zero (not one, as for barycentric coordinates of points).
baryVector3.m
bc = baryVector3( vxs, v ) Express the vector v in terms of the three 3D row vectors in vxs, as a linear combination adding to zero (not one, as for barycentric coordinates of points).
bc2vec.m
v = bc2vec( bc, vxs ) Convert a vector described in barycentric coordinates with respect to the triangle whose vertexes are the rows of the 3*3 matrix vxs, to a vector in global coordinates.
bcgradendpoints.m
pts = bcgradendpoints( v, bc, vxs ) Given v, a vector of the three values of some scalar at the vertexes vxs of a triangle, and bc, the bcs of a point in the triangle. Compute the bcs of the intersection of the line parallel to the gradient vector of v through the point bc with the three sides of the triangle.
bcisoendpoints.m
pts = bcisoendpoints( v, bc ) Given v, a vector of the three values of some scalar at the vertexes of a triangle, and bc, the bcs of a point in the triangle. Consider v as defining a linear function on the triangle. Compute the bcs of the intersection of the isoline of this function through the point bc with the three sides of the triangle.
bestFitEllipsoid.m
principalAxes = bestFitEllipsoid( vxs ) Find the best-fit ellipsoid containing the vertexes VXS, an N*D array where D is the number of dimensions. The result is returned as a matrix of column vectors, being the principal axes of the ellipsoid.
bestFitPlane.m
[c,p,flatness] = bestFitPlane( vxs, weights ) Find the best-fit plane through the vertexes VXS, an N*D array where D is the number of dimensions. The result is returned in the form of C, the centroid of the vertexes, and P, the unit normal vector to the plane through C, both as row vectors. FLATNESS is a measure of how flat the set of points is, and is the ratio of the smallest to second smallest eigenvalue of the covariance matrix. Zero means very flat, 1 means not at all flat. WEIGHTS, if supplied, weights the vertices.
bestRotation.m
r = bestRotation( x, u ) Find the linear transformation of x that best approximates the displacements u, and return its rotational component. The method used here is only valid for small rotations.
cameraFrame.m
[cameraLook, cameraUp, cameraRight] = cameraFrame( ...
CameraPosition, CameraTarget, CameraUp )
Construct the camera orthonormal frame of reference. The arguments are
fields of an axes object.
If called as [cameraLook, cameraUp, cameraRight] = cameraFrame( axes ),
the position, target, and up vectors are taken from the axes object.
Calling it with no arguments is equivalent to cameraFrame( gca ).
Note that cameraUp will not necessarily coincide with CameraUp, since
cameraUp is constrained to be orthogonal to the look direction, while
CameraUp is not.
cameraFrame can be called with a single argument, which is either a
struct containing the three camera parameters, or an axes handle. In
the latter case the camera parameters will be taken from the axes. If
omitted, it defaults to the current axes.
cameraParamsFromOurViewParams.m
camParams = cameraParamsFromOurViewParams( viewParams )
Convert our camera parameters to Matlab's.
Matlab's camera parameters are:
CameraViewAngle
CameraTarget
CameraPosition
CameraUpVector
Our camera parameters are:
fov (field of view)
azimuth
elevation
roll
pan (two components)
targetdistance
See also: ourViewParamsFromCameraParams.
centroids.m
c = centroids( nodes, tricellvxs, triangles ) Find the centroids of the triangles.
circle.m
[xx,yy,zz] = circle( varargin ) Similar to SPHERE, but draws a unit circle in the XY plane, or returns the [xx,yy,zz] data for plotting with SURF. The zz result is always a zero matrix. See also: SPHERE.
circlepoints.m
clipAngleDeg.m
cloudAxes.m
a = cloudAxes( p ) Determine the principal axes of the cloud of points p. p is an N*D matrix, where there are N points in D dimensional space.
clump7.m
convexify.m
vxs = convexify( vxs ) vxs is an N*2 array of points in the plane defining a polygon. They are modified to force the polygon to be convex.
crosses3.m
crossproc1.m
a = crossproc1( b, c ) Equivalent to cross(b,c,1) where b and c are two-dimensional 3*N matrices. See also DOTPROC1, DOTPROC2, CROSSPROC2.
crossproc2.m
a = crossproc2( b, c ) Equivalent to cross(b,c,2) where b and c are two-dimensional 3*N matrices. See also DOTPROC1, DOTPROC2, CROSSPROC2.
decomposedTriangleTransform.m
[th,X,Y,th2] = decomposedTriangleTransform( vxs, wxs ) vxs and wxs are two planar triangles given as 3*2 matrices. There is a unique linear transformation which, combined with a suitable translation (which we are not interested in), maps vxs to wxs. This routine calculates a description of that linear transformation in the form of a rotation by angle TH, followed by growth in the x and y directions of X and Y respectively, followed by rotation by angle TH2. The growth tensor which maps vxs to the same shape as wxs is then [X 0;0 Y]*rotMatrix(th).
diffRect.m
r = diffRect( r1, r2 ) r1 and r2 are rectangles represented as [ xlo, xhi, ylo, yhi ]. r is set to an array of disjoint rectangles whose union is r1 - r2.
dir2azel.m
[ az, el ] = dir2azel( d ) Convert a unit direction vector to azimuth and elevation in degrees. Azimuth and elevation have the meanings given to them by the Matlab function [az,el] = view(). That is, when the azimuth of the view is zero, the positive Y axis points into the screen. When the azimuth is 90, the negative X axis points into the screen. When elevation is zero, the positive Z axis points up the screen. When elevation is positive, the positive Z axis points upwards and out from the screen. When elevation is 90, the positive z axis points directly out of the screen. See also: azel2dir.
dotproc1.m
d = dotproc1( v1, v2 ) Equivalent to dot(v1,v2,1) where v1 and v2 are two-dimensional matrices of the same size. See also DOTPROC2, CROSSPROC1, CROSSPROC2.
dotproc2.m
d = dotproc1( v1, v2 ) Equivalent to dot(v1,v2,2) where v1 and v2 are two-dimensional matrices of the same size. See also DOTPROC1, CROSSPROC1, CROSSPROC2.
drawPlane.m
h = drawPlane( ax, normal, distance, radius, alph ) In the axes AX, draw a rectangle in the plane whose unit normal vector is NORMAL, and which is a DISTANCE from the origin. The semidiameter of the rectangle is RADIUS and its alpha value is ALPH. The centre of the rectangle will be at the closest point of the plane to the origin. NORMAL must be a row vector.
drawVoronoi.m
drawVoronoi( r ) Draw the Voronoi and Delaunay diagrams of the set of points R, a 2*N array.
enclosesLine.m
encloses = enclosesLine( pts, line ) Determine whether a given polygon, defined by pts, its vertexes listed in order, encloses a line, given as a 2*3 array of two points.
eulerRotation.m
rotmatrix = eulerRotation( eulerangles, euleraxes, mode ) Calculate the rotation matrix corresponding to the given Euler angles. Any number of Euler angles can be given. The same number of axis names must also be given in the string EULERAXES, each element of which is 'X', 'Y', or 'Z' (case is ignored). Normally, the rotations are all composed in the global frame. eulerRotation( eulerangles, euleraxes, 'local' ) will compose each rotation in the frame of reference rotated by all the preceding rotations. This is equivalent to applying the rotations all in the global frame and in the reverse order. The resulting matrix is suitable for applying to column vectors: given a column vector V, the result of rotating V by the result is ROTMATRIX*V. If you require a matrix R which can be applied to a row vector V by V*R, take the transpose of ROTMATRIX.
findAltitude.m
[v,a,b] = findaltitude( v1, v2, v3 ) v is the foot of the perpendicular from v1 to the line v2 v3. v is equal to a*v2 + b*v3.
findAreaAndNormal.m
[a,n] = findAreaAndNormal( vxs ) Compute the normal vector and area of a triangle whose vertices are the rows of vxs. We do these together, since this is faster than computing them separately.
findCycle.m
cycle = findCycle( v ) v is an n*2 matrix of vertex indexes, which represents the set of edges of a polygon. cycle is a list of the vertexes in order round the polygon. Since there is no geometrical information present, it is not possible to determine whether the ordering is clockwise or anticlockwise (indeed, the polygon need not be planar). This procedure assumes the data are valid and makes no checks. perm is the permutation such that cycle = perm(v(:,1)).
findgraphpolys.m
polys = findpolys( vxs, edges ) Given a set of vertex positions and a set of edges joining them, and assuming that the whole is a planar graph, find the polygons. VXS is an N*2 aray of vertex positions in the plane. EDGES is an M*2 list of pairs of vertexes. POLYS will be a cell array of arrays of vertexes. VVXS is a list of the neighbours of each vertex, in anticlockwise order of direction, starting from -180 degrees. VEDGES is a list of the directed edges incident on each vertex, in the same order as VEDGES. If the graph is not planar, empty arrays are returned.
findperp.m
w = findperp( v ) Find a 3-element vector perpendicular to the 3-element vector v. In general the result will not be a unit vector, even if v is. v must be a row vector or N*3 array of N row vectors. w will be the same shape as v.
findtriangleareas.m
m = findtriangleareas( nodes, tricellvxs ) Calculate the area of the triangles.
findunitperp.m
w = findunitperp( v ) Find a 3-element unit vector perpendicular to the 3-element unit vector v.
fitRotation.m
[r,c,u1,resid,resid1] = fitRotation( x, u )
Given a set of points x and displacements of those points u, each an
N*3 matrix, find the rotation r about centre c that best fits the
displacements. u1 is set to the residual displacements, resid is set
to the mean squared error of u, and resid1 to that of u1. x, u, r, and
u1 are related by:
for all i, u1(i,:) = u(i,:) - cross(r,x(i,:)) - c
The calculation asumes that the displacements ant rotation are
infinitesimal. Equivalently, if u is a matrix of velocities, r will be
the angular velocity and c the linear velocity which best fit u.
The method is as follows. Define:
ubar = average of u
xbar = average of x
crosscross(a,b) for row vectors a and b = the matrix P-Q, where P is
dot(a,b) times the identity, and Q is a'*b. For matrices of row
vectors, it sums over all the rows. The result is a 3*3 matrix.
Then the desired rotation r satisfies:
(crosscross(u,x) - crosscross(ubar,xbar)) . r =
cross(x,u) - N cross(xbar,ubar)
and c is obtained as c = ubar - cross(r,xbar).
These are the values that minimise the mean squared error.
fitToBbox.m
frameChangeMatrix.m
frameChangePoints.m
getview.m
vp = getview( theaxes ) [az,el] = getview( theaxes ) [az,el,roll] = getview( theaxes ) Get the view parameters from the axes handle. With one output, the whole view structure is returned. With two, only the azimuth and elevation are returned, and with three, roll is also returned. See also: setview.
globalToBaryCoords.m
[cells,bcs] = globalToBaryCoords( bc, nodes, triangles ) Convert global coordinates to barycentric coordinates. NODES is an N*D matrix containing the global coordinates of a set of N points in D dimensions. TRIANGLES is an M*3 matrix containing the indexes of triples of nodes. GC is a C*D array of global coordinates of a set of points. NORMALS is an M*3 matrix giving normal vectors for all the triangles. This argument can be missing or empty, in which case the normals will be computed. HINT, if supplied, is a C*1 array of triangle indexes or a C*1 cell array of arrays of triangle indexes. CELLS will be a C*1 or 1*C vector of indexes of triangles. BCS will be a C*3 array of barycentric coordinates. cells(i) is the index of the triangle that gc(i,:) lies in. bcs(i,:) is the barycentric coordinates of that point with respect to that triangle. See also BARYTOGLOBALCOORDS.
grad.m
gf = grad( vxs, f ) Given a matrix vxs whose three rows are the corners of a triangle, and a three-element row vector f giving the value of a scalar quantity at each corner, determine the gradient of f, assuming it to be parallel to the plane of the triangle. f may validly have K rows, in which case the calculation is performed for each row and the result is a K*3 matrix.
grad2.m
This is a continuous transformation of atan2 that is about twice as fast to compute. It returns values in a range from -0.5 to +0.5 varying continuously and montonically with atan2(pts).
gradOp.m
go = gradOp( vxs ) Given a matrix vxs whose three rows are the corners of a triangle, determine a 3*3 matrix go such that for any 3-element row vector f, f*go is the gradient of the linear interpolation of f over the triangle.
gradOpLinear.m
gol = gradOpLinear( vxs ) Given a matrix vxs whose three rows are the corners of a triangle, determine a 9*9 matrix go such that for any 3*3-matrix v, representing a velocity at each vertex of the triangle, we have reshape(go,[],1) = go * reshape(v,[],1).
gradT.m
gt = gradT( vxs ) Given a matrix vxs whose three rows are the corners of a triangle, calculate a tensor gt such that for any three-element row vector f defining a scalar value at each corner of the triangle, the gradient vector of f (assumed linearly interpolated over the triangle) is f * gt * vxs. gt is a 3*3 symmetric matrix whose rows and columns sum to zero.
insetRect.m
insideSurface.m
isinside = insideSurface( s, v ) Determine whether v is inside or outside the closed surface s. s is assumed to have all its faces oriented so that the right-handed normals point outwards.
interpolateAngle.m
intersectCapsule.m
intersectDepth = intersect_capsule( capsule0, capsule1 )
Determine whether two capsules intersect.
A capsule is a cylinder closed with hemispherical end caps.
The data structure representing a capsule is a struct with these
fields:
ends: a 2xN array, being the two endpoints of the cylinder in
N-dimensional space.
radius: the radius of the cylinder and the hemispheres.
The result is the depth of intersection, positive when they intersect
and negative when they do not. Mathematically, a depth of zero means
that they touch, but due to rounding errors this is not a test that can
be relied on, and zero should be counted either always as intersecting
or always as non-intersecting.
intersectPolygons.m
p = intersectPolygons( p1, p2 ) Compute the intersection of two convex polygons. The polygons are represented as N*2 arrays containing their vertexes in anticlockwise order. The vertexes of the intersection are: (1) Every vertex of one that lies inside the other, and (2) Every intersection of any edge of one with any edge of the other. The only edges that need be tested are those from a point inside to a point outside, and between two points outside.
inv3.m
q = inv3( p ) Compute the inverse of a 3*3 matrix. If the matrix is singular, return the zero matrix and give a warning.
layOutPolygon.m
vxs = layOutPolygon( edges, angles ) Given the set of edge lengths and exterior angles of a polygon, calculate its vertexes in the plane. The first vertex is placed at the origin and the second on the positive x axis. If the exterior angles do not sum to 2pi, they will be adjusted to fit.
lineCutByPolygon.m
v = lineCutByPolygon( pv, vin, vout ) PV is a polygon represented by an N*2 array, which is the N vertexes in order round the polygon (it does not matter which way). VIN is a point known to be inside the polygon, and VOUT a point outside, represented as column vectors. The result V is a point where the line V1 V2 intersects the boundary of the polygon, represented as a column vector.
lineIntersection.m
[b,v] = lineIntersection( v1, v2, v3, v4 ) Find the intersection of the lines v1 v2 and v3 v4. The vectors must be 2-dimensional column vectors. b is true if the lines intersect, v is the intersection. v is not computed unless asked for.
lineLineDistance.m
[d,p,a,q,b] = lineLineDistance( p01, q01 ) p01 and q01 are 2*D arrays, specifying pairs of D-dimensional points. Find the closest point on each of these line segments to the other segment, and the distance between these points. The closest points are expressed both as points and as barycentric coordinates, i.e. p = a(1)*p01(1,:) + a(2)*p01(2,:) and q = b(1)*q01(1,:)+b(2)*q01(2,:). The five results are row vectors of lengths 1, D, 2, D, and 2. p01 and q01 can instead be 2*D*N arrays, and the results will be, respectively, N*1, N*D, N*2, N*D, and N*2 arrays. If N for just one of p01 or q01 is 1, it will be replicated as necessary to match the other.
lineTriangleIntersection.m
[p,pbary,v,e] = intersectLineTriangle( line, tri, insideonly ) Find the intersection of a line and a triangle in 3D. The line is represented as a 2x3 matrix consisting of two 3D points, defining the infinite line passing through them. The triangle is a 3x3 matrix whose rows are the vertexes of the triangle. The result is the intersection point, its barycentric coordinates with respect to the triangle, and the vertex and edge that the point is closest to. The point is in the interior of the triangle if the barycentric coordinates are all positive, on the interior of an edge if exactly one is zero, at a vertex if two are zero, and outside the triangle if any are negative. If the triangle or the line are degenerate, or the line lies in the plane of the triangle, then p and pbary are both returned as all zeros. Note that [0 0 0] is not a valid set of barycentric coordinates. If insideonly is true (the default is false), then if the point lies outside it will be returned as zero, with barycentric coordinates of zero. Note that due to rounding errors it is possible that a point exactly on the edge of the triangle will be detected as lying outside.
lineplaneIntersection.m
[i,r] = lineplaneIntersection( p1, p2, n, c ) Find the intersection between the line through p1 and p2, and the plane through c perpendicular to n. All vectors must be row vectors. r will be the value such that i = p1*(1-2) + p2*r.
localDirection.m
a = localDirection( vxs, v ) VXS is a matrix of 3 row vectors. V is a row vector. A will be set to a vector such that A*VXS is as close as possible to V while satisfying SUM(A) = 0. For this to be useful, V should be roughly in the plane of the three vertexes VXS. V can be an N*3 matrix of vectors, and an N*3 matrix will be returend for A.
makeSquare.m
r = makeSquare( r ) r is a 4-element array [x y w h] such as is used to represent rectangles in GUIs. This procedure trims r to be square, and centres the new square within the old rectangle.
makeframe.m
[v1,v2] = makeframe( v ) V is a unit vector. Chose unit vectors V1 and V2 such that [V V1 V2] is a right-handed coordinate system. If V is a nonzero non-unit unit vector, the resulting vectors will be mutually orthogonal, but may be of arbitrary non-zero lengths. If V is zero, V1 and V2 will be zero.
makeperp.m
v2p = makeperp( v1, v2 ) Construct the vector v2p which is orthogonal to v1 and in the same plane as v2 and v1.
maketristrip.m
Result will be a list of pairs (i,j) signifying an edge from pts1(i,:) to pts2(j,:).
matRot.m
m = matRot( rotAxis, rotAmount ) Calculate the rotation matrix that rotates about the given axis by the given amount in radians. The axis must be a unit vector. Formula cribbed from Wikipedia.
matchTriangleRots.m
[thv,thw] = matchTriangleRots( vxs, wxs ) vxs and wxs are two planar triangles given as 3*2 matrices. Calculate the direction angles thv and thw of unit vectors dv and dw, such that when the triangles are both projected onto the respective lines, their vertices lie in the same order and divide the line in the same ratio; and such that this is also true for projection onto the perpendiculars to the lines. The difference between the two angles is then the rotation that, followed by a non-isotropic expansion, maps vxw onto wxs.
meanpos.m
m = meanpos( nodes, triangles, values ) NODEs is an N*3 array, containing the vertex positions of a mesh. TRIANGLES is an M*3 array of triples of node indexes, defining the triangles of the mesh. VALUES is an N*1 array of values defined at each vertex. Consider VALUES to define the distribution of concentration os a substance over the mesh, linearly interpolated over every triangle. The result will be the centroid of that distribution.
moment2distrib.m
[mom2,centroid] = moment2distrib( nodes, tricellvxs, values, centre ) NODEs is an N*3 array, containing the vertex positions of a mesh. TRIANGLES is an M*3 array of triples of node indexes, defining the triangles of the mesh. VALUES is an N*1 array of values defined at each vertex. CENTRE is a point, by default the centroid of the distribution. Consider VALUES to define the distribution of concentration os a substance over the mesh, linearly interpolated over every triangle. Results: MOM2 will be the second moment of that distribution about the centre. CENTROID (if asked for) will be the centroid of the distribution. If CENTRE is omitted it will default to the centroid; in that case MOM2 is the variance of the distribution. TOTAL (if asked for) will be the total quantity of the distribution. See also: meanpos.
nearestNeighbours.m
r = nearestNeighbours( p1, p2 ) For each point in p1, find the point in p2 that is closest. For all i, p2(r(i),:) is the member of p2 that is closest to p1(i,:). Brute force algorithm.
nearestPointOnLine.m
a = nearestPointOnLine( vxs, p ) VXS is a 3*2 vector containing the ends of a line segment. a is set to the point on that line that is closest to p. (a is not restricted to be within the line segment.)
nearfarpoints.m
[near,far] = nearfarpoints( p, ps ) Find the nearest and farthest points in the set ps from the point p. Return their indexes. p is a row vector of length D, and ps is an N*D matrix.
normaliseAngle.m
a = normalizeAngle( a, mina, degrees, lowerClosed ) An integer multiple of one revolution is added to A as necessary to make it fall in the range [mina...mina+onerevolution]. If lowerClosed is true (the default), then the interval is [mina...mina+onerevolution), otherwise (mina...mina+onerevolution]. If degrees is true (the default), then the calculation is carried out in degrees, otherwise in radians.
normaliseBaryCoords.m
bc = normaliseBaryCoords( bc ) Force all elements of bc to be in the range 0..1 with a sum of 1. bc may be a matrix in which each row is a set of barycentric coordinates.
normaliseNumber.m
a = normaliseNumber( a, lo, hi, lowerClosed ) An integer multiple of HI-LO is added to A as necessary to make it fall in the range [LO..HI]. If lowerClosed is true (the default), then the interval is [LO..HI), otherwise (LO..HI]. LOWERCLOSED defaults to TRUE. HI defaults to LO+1. LO defaults to 0. If LO==HI, every element of A is set to LO. If LO > HI, LO and HI are swapped and LOWERCLOSED is negated.
norms.m
ns = norms( vs ) Calculate the norms of all the row vectors in vs.
normvecs.m
vs = normvecs( vs ) Transform every non-zero row of vs into a unit vector.
ourViewParamsFromCameraParams.m
viewParams = ourViewParamsFromCameraParams( camParams )
Convert Matlab's camera parameters to ours.
camParams may be either an axes handle or a struct containing Matlab's
camera parameters.
Matlab's camera parameters are:
CameraViewAngle
CameraTarget
CameraPosition
CameraUpVector
Our camera parameters are:
fov (field of view)
azimuth
elevation
roll
pan (two components)
targetdistance
camdistance
targetdistance is the distance of the target point behind the plane
through the origin perpendicular to the view direction.
camdistance is the distance of the camera from the target point.
See also: cameraParamsFromOurViewParams.
pathViaEdge.m
v = pathViaEdge( v1, v2, e1, e2 ) Set v3 to the point on the line joining e1 and e2 which minimises the length of the path v1 v v2. All vectors must be row vectors. Error: there is a degenerate case where v1 and v2 both lie on the line from e1 to e2
perVertextoperTriangle.m
perVx = perVertextoperTriangle( tricellvxs, perVx, triangles ) Given a quantity that is defined for each vertex of a triangular mesh, calculate an equivalent quantity per triangle. The per-vertex quantity can be a vector. If m has numVx vertexes and numFEs finite elements, then perVx has size [numVxs,K] for some K, and perTri has size [numFEs,K]. Note that this is an approximation: some smoothing is unavoidable in the calculation. The function perFEtoperVertex translates the other way, but these two functions are not inverses. Converting back and forth will have the side-effect of spreading out the distribution of the quantity.
perpBisIntersect.m
p = perpBisIntersect( v ) v is a 3x2 array representing a triangle in the plane. Set p to the intersection of the perpendicular bisectors of the sides of the triangle.
perpBisIntersect1.m
p = perpBisIntersect1( v ) v is a 3x2 array representing a triangle in the plane. Set p to the intersection of the perpendicular bisectors of the sides of the triangle.
perpendicularBC.m
bcp = perpendicular( vxs, bc ) Given the coordinates of a triangle as a 3*3 matrix of row vectors, and the barycentric coordinates of a vector in that triangle, compute the barycentric corodinates of a perpendicular vector.
placeRectInRect.m
r1 = foo( r, r1, mode ) r and r1 are positions (both of the form [x,y,w,h]). margins is a list of 4 numbers [ml, mb, mr, mt]. glue is an array of compass directions, each of which is n, w, s, or e. The result is a rectangle obtained by first insetting r by the margins to produce a frame rectangle, then attaching the sides of r1 to the sides of the frame wherever the corresponding compass point appears in the glue string. Where a side is unglued, r1 retains its dimension (width or height) in that direction.
planeSide.m
side = planeSide( n, a, pts ) The column vector N and the real number A define a plane by the equation N*X==A. Set SIDE to an array of booleans of length size(p,1), in which each element is truee iff the corresponding row of p satisfies N*P(i,:) >= A.
plotRect.m
plotRect( r ) Plot the rectangles r, an array of which each row has the form [ xlo, xhi, ylo, yhi ].
plotcolouredlines.m
plotlines.m
plotpts.m
plotpts( ax, pts, varargin ) Plot the 2 or 3 dimensional points with any plot options.
pointInPoly.m
inside = pointInPoly( pt, poly ) Determine whether the point is inside the polygon, by computing the winding number of the polygon about the point. The polygon is represented as an N*2 array containing its vertexes in anticlockwise order. If the points are in clockwise order, the result will be true if the point is outside.
pointLineDistance.m
[d,pp] = pointLineDistance( vxs, p, wholeLine ) Find the distance of a point from a line segment. VXS is a 2*D vector containing the ends of the segment, where D is the number of dimensions. pp is the foot of the perpendicular from p to the line. bc is the barycentric coordinates of pp with respect to the ends. If wholeLine is false (the default), then if pp lies outside the line segment, it will be moved to the nearer end. However, bc will be unchanged. To determine from the result whether pp was moved, look at bc: one of its components will be negative in that case. In both cases, d will be the distance from p to pp.
pointPlaneDistance.m
d = pointPlaneDistance( vxs, p ) Find the distance from the point p to the plane through the given three vertexes vxs. The result is always nonnegative. d = pointPlaneDistance( planeCentre, planeNormal, p ) Find the distance from the point p to the plane through planeCentre with unit normal vector planeNormal. The result is positive if p is on the same side of planeCentre as planeNormal.
pointPointDistance.m
d = pointPointDistance( p0, p1 ) Return the distances between corresponding members of the N*K arrays p0 and p1 of N K-dimensional points. Either p0 or p1 can be a single point, in which case its distance from all the points in the other set will be calculated.
pointTransform.m
Calculate a 3*2 matrix describing an affine transformation mapping v1 to w1 and v2 to w2. The transformation must consist of translation, scaling, and rotation only. Given a N*2 array of points n, the new value of n should be [n,ones(size(n,1),1)]*mx)[:,1:2].
pointTriangleDistance.m
d = pointTriangleDistance( vxs, p ) Find the distance from a point to a triangle.
polyCentroid.m
c = polyCentroid( v ) Compute the centroid of the polygon whose vertexes are the rows of v. The polygon must be 2 or 3 dimensional.
polySelfIntersect.m
polySelfIntersect( pts ) PTS is the set of vertexes of a polygon in the plane, listed in anticlockwise order. The result is a list of self-intersections. Each row contains 4 elements: [A,B,C,D] means that the edge from A to B intersects the edge from C to D.
polyarea3.m
POLYAREA3 Area of polygon in 3D space.
POLYAREA3(X,Y,Z) returns the area of the polygon specified by
the vertices in the vectors X, Y, and Z. If X, Y, and Z are matrices
of the same size, then POLYAREA3 returns the area of
polygons defined by the columns of X, Y, and Z. If X, Y, and Z are
arrays, POLYAREA3 returns the area of the polygons in the
first non-singleton dimension of X, Y, and Z.
POLYAREA3(X,Y,Z,DIM) returns the area of the polygons specified
by the vertices in the dimension DIM.
POLYAREA3(M), where M is an N*3 matrix, is equivalent to
POLYAREA3( M(:,1), M(:,2), M(:,3), 1 ).
If the polygon is not flat, the area computed is the total area of all
the triangles formed by the centroid of the vertices and every
consecutive pair of vertices of the polygon.
Based on the Matlab code for POLYAREA.
See also: POLYAREA.
polygonArea.m
a = polygonArea( d, vxs ) Compute a representation of the area of a polygon in 3D cut off by a plane perpendicular to d. The polygon vertexes are in the N*3 array vxs. d must be a unit row vector. n is a vector normal to the polygon. If omitted, it defaults to [0 0 1].
polygonArea2.m
a = polygonArea2( d, vxs ) Compute a representation of the area of a polygon in the XY plane cut off by a line parallel to the Y axis. The polygon vertexes are in the N*2 array vxs.
polygoncentre.m
centre = polygoncentre( vxs ) Find the centroid of a polygon.
polysplitdiameter.m
[c,v] = polysplitdiameter( vxs ) Given an N*2 matrix of vertexes of a 2D polygon, find the centroid c of the polygon and a unit vector v, such that the distance from c along v to an edge of the polygon is minimised.
povrayParamsFromOurViewParams.m
povrayParams = povrayParamsFromOurViewParams( viewParams )
Convert our camera parameters to POV-Ray's.
POV-Ray's camera parameters are:
perspective|orthographic
location: a vector
look_at: a vector
right: a vector
up: a vector
direction: a vector
Our camera parameters are:
fov (field of view)
azimuth
elevation
roll
pan (two components)
targetdistance
See also: ourViewParamsFromCameraParams.
projectPointToLine.m
[pp,bc] = projectPointToLine( vxs, p ) Project P perpendicularly onto the line defined by the two vertexes VXS, giving point P1. VXS is a 2*D matrix of two row vectors of any dimensionality D. If the two points coincide, then PP is set equal to both. BC is set to the barycentric coordinates of the point with respect to VXS, as a 1*D row vector. The equality PP == BCS*VXS holds. P may be an N*D matrix of row vectors for any N.
projectPointToPlane.m
pp = projectPointToPlane( vxs, p ) Project P perpendicularly onto the plane defined by the three vertexes VXS, giving point PP. VXS is a 3*D matrix of three row vectors of any dimensionality D. If the three points are collinear, then P is projected onto the line they define. BC is set to the barycentric coordinates of the projected point with respect to VXS, as a 1*D row vector. The equality PP == BCS*VXS holds. P may be an N*D matrix of row vectors for any N.
projectPointToPlane2.m
p = projectPointToPlane2( point, normal, distance ) Project POINT to the plane normal to NORMAL at DISTANCE from the origin. p = projectPointToPlane2( point, normal, through ) Project POINT to the plane normal to NORMAL that passes through the point THROUGH. NORMAL must be nonzero, but does not have to be a unit vector. POINT can be an N*D matrix of D-dimensional points. If RATIO is supplied, the points will not be moved the full distance to the plane, but only the given proportion of the distance. Thus RATIO=1 gives full flattening, RATIO=0 gives no change.
projectstreamline.m
gradendpoint = projectstreamline( v, bc, vxs, positive ) Given v, a vector of the three values of some scalar at the vertexes vxs of a triangle, and bc, the bcs of a point in the triangle. Compute the bcs of the intersection of the line parallel to the gradient vector of v, in either the direction of the gradient vector or its opposite or both, starting from the point bc, with the first side of the triangle that it hits. If POSITIVE is true, only the intersection in the direction of the gradient is returned. If POSITIVE is false, only the intersection in the opposite direction is returned. If POSITIVE is not supplied, both intersections are returned. If two output arguments are supplied, the positive intersection is returned in gradendpoint1 and the negative in gradendpoint2. If one output argument is supplied, it will hold the intersection that was asked for, if POSITIVE was supplied, otherwise it will hold the positive intersection. Any intersection asked for which does not exist, because it lies outside the triangle, is returned as the empty list.
quivervec.m
randInCircle2.m
randPointsOnSurface.m
[cellindexes,bcs,pts] = randPointsOnSurface( nodes, tricellvxs, areas, d, hintFE, hintBC ) Choose a maximal set of points on a surface defined by a set of nodes and a set of triangles, subject to the condition that the distance between any two points is greater than d. The AREAS argument is a vector of the areas of the triangles. This can be calculated from the nodes and tricellvxs arguments, but in the circumstances where we call this, we already have the areas to hand. We use an approximate algorithm for this: first we generate many points at random, far more than the number we estimate that we will eventually select. Then we select from these points one by one, adding a point to the selected set if it is far enough from each of the previously selected points. The more points we generate, the less likely we are to have a chance void in our pattern, where we should have added another point but did not. But the more points we generate, the longer the algorithm takes. If hintFE and hintBC are supplied, these points are used before any of the generated points. The result consists of a vector of triangle indexes, the barycentric coordinates of the selected points in those triangles, and the 3d coordinates of the points. This method generates a set of points that are guaranteed to be at least d apart from each other, and (if the initial sample is large enough) will ensure that no other point of the surface is more than a distance d from the nearest member of the set. This still allows for some lumpiness: there can be voids in the pattern whose shortest diameter is up to 2d.
randRotation.m
r = randRotation() Generate a random rotation matrix in 3 dimensions.
randomDirection.m
newdir = randomDirection( curstart, radius, curdir, maxangle, surfnormal, insurface, usemaxangle, N ) Generate a random direction that deviates by not more than maxangle from currentdir, and which is uniformly distributed over the spherical cap that is the space of all permitted directions. If surfnormal is supplied, nonempty, and nonzero, limit the new vector to the subset making an angle with surfnormal of more than 90 degrees. If maxangle is empty, all directions are permitted, the same as if maxangle were pi or more. insurface is a boolean. If false, the above happens, but if true, the new direction is constrained to lie parallel to the surface, i.e. perpendicular to surfnormal. (surfnormal must be supplied and nonzero in this case.) The new direction is randomly uniformly distributed over the range of permitted angles in the surface. curdir must be a row vector. newdir will be a unit length row vector. The default value of N is 1. A larger value can be supplied to generate any number of random directions as an N*3 matrix.
randperp.m
w = randperp( v ) Return a random unit vector perpendicular to the unit vector v. v may be an N*3 matrix of row vectors, in which case an N*3 matrix will be returned, of a random perpendicular to each row of v.
rectInRect.m
r1 = rectInRect( r, where, pos ) POS is an array [insetx, insety, width, height]. Set r1 to be a rectangle of size [width height], inset by insetx and insety from the edges of R indicated by WHERE, which is a string being one of 'n', 's', 'w', 'e', 'ne', 'ne, 'sw', 'se', 'c'. x and y are assumed to increase to the right and up.
rectifyFOV_MVP.m
matlabViewParams = rectifyFOV_MVP( matlabViewParams, newfov ) Set the field of view angle, and change the camera distance so that in orthographic projection, the visible appearance of the scene is unchanged. This computation is carried out in terms of Matlab's view parameters. newfov is given in degrees.
rectifyFOV_OVP.m
ourViewParams = rectifyFOV_OVP( ourViewParams, newfov ) Set the field of view angle, and change the camera distance so that in orthographic projection, the visible appearance of the scene is unchanged. This computation is carried out in terms of our view parameters. newfov is given in degrees.
rotVec.m
v = rotVec( v, centre, rotAxis, rotAmount ) Rotate v about the axis rotAxis passing through centre by rotAmount in radians. v may be a 3-element row vector or an N*3 matrix.
rotateElastMatrix2.m
rotD = rotateElastMatrix( D, J ) D is a 2D elasticity tensor in 3-matrix form. The result is the rotation of D by J, a 2D rotation matrix or a rotation angle.
rotateTensor.m
t1 = rotateTensor( t0, r ) t0 is a tensor in 6-vector form, i.e. [ xx, yy, zz, yz, zx, xy ], or 3-vector form [xx yy xy]. r is a rotation matrix in 3 or 2 dimensions respectively. The result is t rotated by r. t may be a matrix of N row vectors, in which case t1 will also be.
rotmat2To3mat.m
J3 = rotmat2To3mat( J ) Convert a 2*2 rotation matrix to 3-matrix form, suitable for rotating elasticity tensors in 3-matrix form.
setaxis.m
setaxis( theaxes, axisrange, centre ) This works like axis, but assumes that the camera is on manual mode, and does the automatic camera ranging. If centre is true (the default) then the view will be adjusted to pass through the centre of the axis box.
setview.m
setview( theaxes, vp ) setview( theaxes, az, el ) setview( theaxes, az, el, roll ) Set the view parameters of the axes handle. Either the whole view parameters structure can be given, or just azimuth and elevation, or azimuth, elevation, and roll.
simpleplotmesh.m
smoothGrid.m
smoothSurface.m
s = smoothSurface( s, n ) Given a surface S as returned by isosurface(), smooth it by averaging each point with its neighbours, N times. N defaults to 1.
sparsifyPoints.m
subpts = sparsifyPoints( pts, distance ) Given a set of points as an N*D matrix, and a distance, choose a maximal subset of the points such that no two members of the subset are within a distance of less than distance. The indexes of the selected points are returned in a column vector. If distance is zero, points with identical coordinates will be deemed to be too close. Thus setting distance=0 amounts to striking out all duplicates. If distance is negative, 1:size(pts,1) is returned immediately.
splaynodes.m
n is assumed to be a N*3 array of points, assumed to have x and y coordinates all lying in the sector whose vertex is at the origin and which is bounded by angles a1 and a2. The points are rotated and transformed so as to lie in the sector bounded by angles a3 and a4.
spline3.m
x = spline3( x0, x1, x2, x3, alpha ) Interpolate a cubic spline through the four points, which may be in space of any number of dimensions. The spline will pass through the four points at alpha = -1, 0, 1, and 2 respectively. If x0...x3 are row vectors and alpha is a column vector then x will be a matrix of row vectors; and vice versa.
splinePoints.m
Given a set of points PTS (an N*3 array) and a vector of value in the
range 0..1, calculate the positions of a set of points INTERPPTS, such
that the i'th point is a proportion interps(i) of the way along a smooth
path through all the given points.
The return value THESPLINE is a data structure from which further
interpolants can be computed by the PPVAL function. For example, the
returned value of INTERPPTS is calculated by:
interppts = ppval( thespline, interps )';
Note that ppval returns a 3*K array of K points (K being the length of
INTERPS), so for consistency with our convention that PTS is N*3, this
array is transposed before being returned.
splitBaryCoords.m
bc = splitBaryCoords( bc, femCell, newFemCell, splitv1, splitv2 ) bc is the barycentric coordinates of a point in the cell FEMCELL, which has just been split, the added cell being NEWFEMCELL. The edge that was split has endpoints SPLITV1 and SPLITV2 relative to the old cell, where these are indexes in the range 1:3. Calculate the new barycentric coordinates of the same point, and its cell index.
splitPoly.m
[vi1a,vi1b,v1,vi2a,vi2b,v2] = splitPoly( direction, splitpoint, vxs ) vxs contains the vertexes of a polygon as an N*3 matrix. direction is a direction and splitpoint a point. This routine finds where the plane perpendicular to direction through splitpoint intersects the polygon.
splitPolyShortest.m
[vi1a,vi1b,v1,vi2a,vi2b,v2] = splitPolyShortest( splitpoint, vxs ) Find the shortest line through splitpoint cutting the polygon vxs. The results are
splitPolygonByArea.m
splitVector.m
[par,per] = splitVector( v, n ) Split a row vector r into its components parallel and perpendicular to the row vector n. r and n can be N*3 matrices.
splitbc.m
newbc = splitbc( oldbc, splitinfo ) When a finite element is split, any points within it that were defined by their barycentric coordinates must have those coordinate recomputed, and the descendant cell containing the point must be found. That is done by this function. ci is the cell that was split. splitinfo is an array of six elements [ ci1, ci2, ci3, nc1, nc2, nc3 ]. ci1, ci2, and ci3 are the indexes within the cell of the edges that were split. If only two edges were split, ci3 is zero, and if only one edge, ci2 is also zero. nc1, nc2, and nc3 are the indexes of the new cells. If only two edges were split, nc3 is zero, and if only one edge, nc2 is also zero. The edges and cells are listed in a canonical order, for which see the code here, or look at how splitinfo is computed in splitalledges.m.
squarebc.m
bc4 = squarebc( bc, d ) Return the barycentric coordinates of a quadrilateral centred on bc with radius d.
stereoOffset.m
[cameraPosition, cameraRight] = ... stereoOffset( cameraPosition, cameraTarget, cameraUp, cameraRight, offset ) Rotate cameraPosition and cameraRight by offset about cameraUp through cameraTarget. offset is in degrees. The vectors should be row vectors.
subdivide4.m
p = subdivide4( v ) Given a 4*3 matrix holding four points, find a point on a smooth curve through the four points, about halfway between the middle two points.
surfaceNeighbours.m
nb = surfaceNeighbours( s ) % Given a surface S as returned by isosurface(), return a cell array listing for each vertex, the indexes of its neighbours.
tensorVector.m
g = tensorVector( t, v ) Given a growth tensor t in 2 or 3 dimensions, and a column vector v, compute the growth in direction v (scaled as |v| squared), i.e. g = v' t v. t is assumed given in 3-vector format for 2 dimensions, or 6-vector format for 3 dimensions.
tensorsToComponents.m
[cs,fs] = tensorsToComponents( ts, preferredframes ) Convert a set of growth tensors ts given as an N*6 matrix into an N*3 matrix cs of the growth amounts and a 3*3*N matrix of the axis frames. preferredframes is an optional argument. If not supplied, then the values in cs will be in descending order. If supplied and maxmin is false or absent, the columns of the matrices in fs will be permuted to lie as close as possible to those of preferredframes, and cs will be permuted likewise. If maxmin is true then the first two elements in each row of cs will be permuted to place the largest first, and the corresponding axes likewise permuted.
testdv.m
testperpbis.m
testpoly.m
tetrahedronAngle.m
a = tetrahedronAngle( v1, v2, v3, v4 ) The arguments are the four vertices of a tetrahedron. Return the angle between the two faces joined by the edge v1 v2.
timevor.m
translatearray.m
triAltitudes.m
triInterpolate.m
gv = triInterpolate( points, v ) v is a row vector of 3 values, the values of some quantity at the vertexes of a triangle. points is a 3*N matrix of points in barycentric coordinates. The result is the interpolated values of v at those points.
triangleAngle.m
a = triangleAngles( tri ) TRI is a 3*3 matrix of row vectors, the vertexes of a triangle. A is set to the angle at the first vertex. If you want all three angles, use triangleAngles.
triangleAngles.m
a = triangleAngles( tri ) TRI is a 3*3 matrix of row vectors, the vertexes of a triangle. A is set to the angles of the triangle, as a column vector.
triangleQuality.m
q = triangleQuality( pts ) Compute a measure of the quality of the triangular FEM element whose vertexes are the rows of pts. The measure is the ratio of twice the triangle area to the square of its longest side. Equivalently, it is the ratio of the altitude to the longest side. The maximum possible value is sqrt(3)/2 = 0.866.
triangleTransform.m
t = triangleTransform( vxs1, vxs2, growthonly ) Find the affine transformation that maps the triangle vxs1 to the triangle vxs2, both being 3*2 matrices representing three points in the plane. The transformation t is a 3*2 matrix satisfying [ vxs1, [1; 1; 1] ]*t = vxs2. It exists and is unique unless the points vxs1 are collinear. If growthonly is true (default false) then the translationsl and rotational parts of t will be removed and t returned as a 2*2 symmetric matrix.
trianglearea.m
ta = trianglearea( vxs ) Compute the area of the triangle in 3D space whose vertices are the rows of vxs. If the third dimension of vxs is greater than 1, this calculation will be carried out for every slice.
triangleareas.m
[areas,normals] = triangleareas( nodes, triangles ) Compute the areas and normal vectors to a set of triangles specified by the positions of their vertexes and the triples of vertexes that make the triangles.
trianglesAngles.m
a = trianglesAngles( tri ) TRI is a 3*3*N matrix of row vectors, the vertexes of N triangles. A is set to the angles of all the triangles, as a 3*N matrix. The triangles are assumed to be all non-degenerate.
triangulate.m
t = triangulate( vxs ) Create a triangulation of the given vertexes. VXS is an N*2 array listing the vertexes of a polygon in order. T will be a K*3 array of triples of indexes of V.
triframe.m
frame = triframe( t ) Calculate a right-handed orthonormal frame of reference for a triangle t, such that the third axis is the triangle normal, and the first is one of its edges. The vertices of the triangle are the rows of t.
trinormal.m
normal = trinormal( t ) Calculate a normal vector to the triangle whose vertices are the rows of t. The length of the vector is twice the area of the triangle. If the three points are collinear, the vector will be zero.
tritransformation.m
mx = tritransformation( vxsA, vxsB ) Compute a linear transformation mapping the triangle whose vertexes are the rows of vxsA to the triangle given by vxsB, assuming the unit normal vector of the first is mapped to the unit normal vector of the second. mx should have the property that vxsA*mx differs from vxsB by a translation. The translation from vxsA*mx to vxsB is vxsB(1,:) - vxsA(1,:)*mx.
vec2bc.m
bc = vec2bc( v, vxs ) Convert a vector to barycentric coordinates with respect to the triangle whose vertexes are the rows of the 3*3 matrix vxs. n, if supplied and nonempty, is a normal vector to the triangle.
vec3Angle.m
vecangle2.m
voronoiChange.m
voronoiChange( v, dv )
V is a set of voronoi generating points.
DV is a perturbation to V.
We compute the change in edge lengths of the Voronoi tessellation of V
when DV is added to V, on the assumption that the topology of the
network does not change. Since smalledges tend to be fragile, we
ignore edges whose length is less than 0.2 of the typical cell
diameter.
Several measures of edge shrinkage are returned:
NS: the number of edges, originally above the threshold length,
which shrank.
FS: the fraction of edges, originally above the threshold length,
which shrank.
AMT: geometric mean of the shrinkage, taking non-shrinking edges to
have zero shrinkage.
voronoiFromDelaunay.m
vv = voronoiFromDelaunay( v, t ) Calculate the Voronoi vertexes from the Delaunay trangulation t of a set of vertexes V.
vorticity.m
v = vorticity( x, u ) Given N*3 matrices x and u of points and displacements respectively, find the best-fit rigid rotation v. EXPERIMENTAL CODE, DO NOT USE YET.
whichSide.m
z = whichSide( n, p, v ) Returns 1 or 0, depending on which side v is of the hyperplane perpendicular to n through p. n and p must be row vectors, and v a matrix of row vectors. z will be a column vector of booleans.
windingNumber.m
wrappoints.m
v = wrappoints( v, r ) Wrap the set of points around a cylinder whose axis is the z-axis, with radius r.
xorRect.m
r = xorRect( r1, r2 ) r1 and r2 are rectangles represented as [ xlo, xhi, ylo, yhi ]. r is set to an array of disjoint rectangles whose union is the symmetric difference of r1 and r2.
xvoronoi.m
XVORONOI Modified Voronoi diagram.
By RK, based on Matlab's VORONOI.
VORONOI(X,Y) plots the Voronoi diagram for the points X,Y. Lines-to-
infinity are approximated with an arbitrarily distant endpoint.
VORONOI(X,Y,TRI) uses the triangulation TRI instead of
computing it via DELAUNAY.
VORONOI(X,Y,OPTIONS) specifies a cell array of strings to be used as
options in Qhull via DELAUNAY.
If OPTIONS is [], the default DELAUNAY options will be used.
If OPTIONS is {}, no options will be used, not even the default.
VORONOI(AX,...) plots into AX instead of GCA.
H = VORONOI(...,'LineSpec') plots the diagram with color and linestyle
specified and returns handles to the line objects created in H.
[VX,VY] = VORONOI(...) returns the vertices of the Voronoi edges in VX
and VY so that plot(VX,VY,'-',X,Y,'.') creates the Voronoi diagram.
The lines-to-infinity are the last columns of VX and VY. To
ensure the lines-to-infinity do not affect the settings of the axis
limits, use the commands:
h = plot(VX,VY,'-',X,Y,'.');
set(h(1:end-1),'xliminclude','off','yliminclude','off')
For the topology of the voronoi diagram, i.e. the vertices for
each voronoi cell, use the function VORONOIN as follows:
[V,C] = VORONOIN([X(:) Y(:)])
See also VORONOIN, DELAUNAY, CONVHULL.
ypiecequadpos.m
v = ypiecequadpos( u, v ) Calculate the 3D position of a point on the basic quadilateral, of which 12 copies form the basic y-shaped junction of three tubes.
HSVtoRGB.m
rgb = HSVtoRGB( h, s, b ) Better version of hsv2rgb that allows any real number as a value of h, and trims s and b to the range 0..1.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Utils\MSR
msrConvertBaseIndex.m
msr = msrConvertBaseIndex( msr, baseIndex ) Convert an MSR structure such as returned by msrfilereader or as supplied to msrfilewriter between 0-indexing and 1-indexing. MSR files use 0-indexing for those fields that consist of indexes into other fields, i.e. the lower index is zero. Matlab indexes arrays from 1. Therefore it is necessary to convert between 0- and 1-indexing in order to process MSR data in Matlab. baseIndex is the indexing mode that is required for the result. If baseIndex is zero, the given msr structure is assumed to currently be 1-indexed, and 1 is subtracted from every array index it contains. If baseIndex is 1, the given msr structure is assumed to currently be 0-indexed, and 1 is added to every array index it contains. This procedure will rarely be called by the end user, as msrfilereader and msrfilewriter automatically call this already.
msrfilereader.m
[result,errs] = msrfilereader( filename ) Read the given MSR file and return its contents as a Matlab structure. All error messages generated in the process are returned in the cell array of strings ERRS. Run this on an example file to see what the returned structure looks like. msrfilereader tries to know as little as possible about the data. It has hard-wired into it the data type associated with each field name (string, integer, or float) and how many data items there should be, but this information should be stored in an external file instead. Unknown field names default to expecting any number of string values. Because MSR data indexes its arrays from 0, and Matlab indexes arrays from 1, all array indexes present in the data must be converted from one convention to the other when reading or writing this format. msrfilereader therefore needs to know which fields contain array indexes. These fields are (currently) assumed to be OBJECT, EDGE, and FACE. If an MSR file contains any other fields containing array indexes that you are going to use as such, you will have to convert them yourself after reading the data. This procedure uses tokeniseString() in the Growth Toolbox.
msrfilewriter.m
[ok,errs] = msrfilewriter( filename, msr ) Write an MSR structure as returned by MSRFILEREADER to the given file. If the filename is empty then output will be to the console. If MSR is missing or empty then no file will be touched. OK is a boolean to say whether the operation succeeded. If it fails, ERRS will be a cell array of associated error message strings. Because MSR data indexes its arrays from 0, and Matlab indexes arrays from 1, all array indexes present in the data must be converted from one convention to the other when reading or writing this format. msrfilewriter therefore needs to know which fields contain array indexes. These fields are (currently) assumed to be OBJECT, EDGE, and FACE. If an MSR file contains any other fields containing array indexes that you are going to use as such, you will have to convert them yourself before writing the data.
testmsr.m
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Utils\Maths
arithprog.m
a = arithprog( first, last, n ) Return an array of n integers, beginning with FIRST and ending with LAST, and being as equally spaced as possible between,
averageAngle.m
a = averageAngle( angles, weights ) Take the weighted average of the given angles. If there are N angles, there are N candidates for the average, depending on which candidate value is selected for each angle. Choose the one that minimises the variance. If there is more than one, choose one at random. The angles are assumed to be in radians.
averageDirection.m
v = averageDirection( vectors, weights, normal ) VECTORS is an N*3 matrix of unit row vectors. WEIGHTS is a vector of N weights summing to 1. The result is a unit vector whose direction is in some sense the weighted average of the directions of the given vectors. It is constrained to be perpendicular to NORMAL, and the given vectors are expected to be at least approximately perpendicular to NORMAL. If NORMAL is not supplied, it defaults to [0 0 1]. There is no continuous averaging operation in the space of unit vectors. Therefore, this function is discontinuous. There is more than one plausible candidate for the "average". The one we implement is to take the weighted average of the vectors, project it perpendicular to NORMAL, then normalise it to unit length. If the projection of the average is zero, a random perpendicular to NORMAL is returned. An alternative method is to choose the direction that minimises the second moment of the distribution of the directions around that value. An implementation of that is available in the code below, but only for the case where NORMAL is [0 0 1].
bestFitLine2D.m
theta = bestFitLine2D( pts ) Find the direction of the line through the centroid of the given points that minimises the sum of the squares of the distances of the points from the line. pts must be an N*2 array. theta will be an angle between -PI/2 and +PI/2. Both limits are possible.
bestflipvxs.m
pts = bestflipvxs( pts ) pts is an Nx2 matrix of N points in the plane. Reflect this set about a line chosen to minimise the total squared displacement of all the points.
cancelMoment.m
w = cancelMoment( u, d, cancelDrift ) d is a set of velocities of particles at positions u. Calculate the angular velocity about the centroid of u that will cancel out the moment of the velocities d. If cancelDrift is true (default is false), then d will also be translated to make its average zero. The moment of velocities (assuming the centroid is zero) is sum_i u_i cross d_i.
cfrac.m
a = cfrac( r, n ) Calculate the continued fraction representation of r to n places.
checkUniqueRows.m
clumplinear.m
[cnum,cmin,cstep,csz,clumpindex] = clumplinear( v )
v is a vector which is expected to consist of a large number of values
that fall into clumps clustered around a smaller number of values.
These clump values are expected to be in arithmetic progression.
This routine finds the best-fit description of this form.
Results:
cnum The number of clumps
cmin The central value of the zeroth clump.
cstep The distance between central values of consecutive clumps.
csz The maximum difference of any clump member from its central
value.
clumpindex A row vector the same length as v, mapping each index
of v to the index of the clump it belongs to.
Thus v(i) is approximated by cmin + cstep*clumpindex(i), and the error
is bounded by csz.
v can also be a matrix of any size and number of dimensions.
clumpindex will have the same size and shape as v.
See also: clumpsize, clumpseparation, clumpsepsize.
clumpseparation.m
cs = clumpseparation( v ) v is a vector which is expected to consist of a large number of values that fall into clumps clustered around a smaller number of values. The spread of values within each clump is expected to be much smaller than the difference of values between any two clumps. This routine returns the minimum separation found between any two members of different clumps. v can be a row or column vector, or a matrix of any shape. See also: clumpsize, clumpsepsize, clumplinear.
clumpsepsize.m
[csep,csz] = clumpsepsize( v ) Returns the results of clumpsize(v) and clumpseparation(v), but is more efficient than calling both of those separately. See also: clumpsize, clumpseparation, clumplinear.
clumpsize.m
csz = clumpsize( v ) v is a vector which is expected to consist of a large number of values that fall into clumps clustered around a smaller number of values. The spread of values within each clump is expected to be much smaller than the difference of values between any two clumps. This routine returns the maximum separation found between any two members of the same clump. v can be a row or column vector. See also: clumpseparation, clumpsepsize, clumplinear.
combinations.m
c = combinations(n,i) Calculate n!/i!(n-i)!
convertIsoElasticParams.m
s = convertIsoElasticParams( p1, v1, p2, v2 )
Given any two of the six standard elastic parameters of a 3-dimensional
isotropic material, return a struct containing all of them:
s.bulk bulk modulus
s.young Young's modulus
s.lame1 Lame's first parameter
s.shear shear modulus
s.poisson Poisson's ratio (also called Lame's second parameter)
s.pwave P-wave modulus
p1 and p2 are any two distinct field names from the above list, and v1
and v2 are their values.
For certain pairs (young and either lame1 or pwave), the computation
requires the solution of a quadratic equation, and hence there are two
solutions. Only one solution will be returned, and when possible, it
will be a physically realistic one (i.e. all properties except
s.poisson will be non-negative, and s.poisson will be in the range
-1...0.5). Some of the calculations will be singular when s.poisson is
-1 or 0.5.
If the arguments p1 and p2 are equal, or either is unrecognised, an
empty result is returned.
diffs.m
dv = diffs( v ) Set dv to the vector of differences between consecutive members of v. v must be nonempty.
efrac.m
r = efrac( cf ) Evaluate a continued fraction.
extractRotation.m
q = extractRotation( q, tol ) Find the rotational component of a polar decomposition of q. See http://www.cs.wisc.edu/graphics/Courses/838-s2002/Papers/polar-decomp.pdf http://tog.acm.org/resources/GraphicsGems/gemsiv/polar_decomp/Decompose.c http://eprints.ma.man.ac.uk/340/01/covered/MIMS_ep2006_161.pdf If the determinant of q is negative, the decomposition will be a combination of rotation and reflection. The tolerance defaults to 1e-6.
fitmat.m
[m,t] = fitmat( p0, p1 ) P0 and P1 are N*2 or N*3 arrays of 2D or 3D vectors. [M,T] are the linear transformation and translation that best approximate the transformation of P0 to P1. T is P1mean-P0mean, and M is chosen to minimise the squared error of (P1-P1mean) - (P0-P0mean)*M. If M is close to singular, it is returned as the identity matrix instead.
fourpointforce.m
forces = fourpointforce( torque, vxs, n3, n4 ) Given a 4*3 matrix of points [v1;v2;v3;v4] and equal and opposite torques TORQUE about the line V1 V2, find a set of forces on the four vertexes equivalent to those torques. The torques are assumed to be trying to move vertexes v3 and v4 in the direction of the normal vectors n3 and n4. If n3 and n4 are not supplied, they are calculated from the vertexes, assuming that v1 v2 v3 ans v4 v2 v1 are anticlockwise enumerations.
genrand.m
r = genrand( df, n ) df is a cumulative distribution function over its subscript range. This function generates n random elements drawn from that distribution. Where consecutive members of cumdist are equal, the later element will always be chosen.
interpolateArray.m
c = interpolateArray( v, cmap, crange ) C is the color produced by mapping V into the color map CMAP. V can be a column vector of length N and C will be an N*3 matrix.
inv3n.m
M is a 3*3*N matrix. Each of its 3*3 slices is inverted.
isoproducts.m
M = isoproducts( vxs )
Calculate the integral of the product of any two isoparametric shape
functions over the pentahedron given by the 6*3 array vxs. The
standard pentahedron has the vertex array:
[ 1 0 -1;
0 1 -1;
0 0 -1;
1 0 1;
0 1 1;
1 1 1 ];
and the given vertexes are assumed to be listed in the same order.
The result is a 6*6 array M, which is indexed along both dimensions by
the first index of vxs.
M is symmetric, and its upper right 3*3 quadrant is symmetric.
This means that the matrix has at most 18 independent elements. This
must be an over-estimate, though. M is a function of vxs, which
already only has 18 dfs. M is invariant under volume-preserving linear
transformations, which have 8 dfs, leaving only 10 dfs for M. 10 is
the number of dfs of a symmetric 4*4 matrix. Furthermore, M is
determined by the coefficients td1, tdx, etc. computed below. There
are only 9 of these, so M has at most 9 degrees of freedom. In fact,
tdxzz and tdyzz are identically zero, leaving only 7 dfs.
For the standard pentahedron, M is:
[ 4 2 2 2 1 1
2 4 2 1 2 1
2 2 4 1 1 2
2 1 1 4 2 2
1 2 1 2 4 2
1 1 2 2 2 4 ] / 72
Its elementwise reciprocal is:
[ 1 2 2 2 4 4
2 1 2 4 2 4
2 2 1 4 4 2
2 4 4 1 2 2
4 1 4 2 1 2
4 4 2 2 2 1 ] * 18
Its inverse is
[ 6 -2 -2 -3 1 1
-2 6 -2 1 -3 1
-2 -2 6 1 1 -3
-3 1 1 6 -2 -2
1 -3 1 -2 6 -2
1 1 -3 -2 -2 6 ] * 6
Under linear transformations M is scaled by the determinant, and hence
M is invariant under rigid motions and shears.
More general movements of the six vertices break much of the symmetry.
Pathological pentahedra can have zero volume, and in this case M is
singular.
When there is no interpenetration of faces, M is non-singular, and its
determinant has the same sign as the volume. In finite element
calculations, the vertexes should be numbered in such a way that the
volume is positive. This means that the outward surface normal for the
triangle vxs([4 5 6],:) should follow the right-hand rule for that
listing of those vertexes.
The standard pentahedron can be parameterised by the coordinates x, y,
and z. Every other pentahedron can inherit this parameterisation, by
interpreting x and y as two of the barycentric coordinates on the
triangles vxs([1 2 3],:) and vxs([4 5 6],:), and z as parameterising
each of the lines vxs([1 4],:), vxs([2 5],:), and vxs([3 6],:). z thus
represents the pentahedron as a stack of triangles, to which the
barycentric coordinates x and y can be applied.
To obtain the integral of any quantity Q defined in terms of these
coordinates, one integrates over the standard pentahedron the quantity
Q*D, where D is the dilation of the mapping of the standard pentahedron
to the one we are integrating over. D is the determinant of the
Jacobian of the transformation, as a function of the x, y, and z
coordinates in the standard pentahedron. This is a cubic polynomial in
x, y, and z, the coefficients of which are calculated below as the
quantities tp1 (the linear term), tpx (the term in x), etc., up to
tpyzz (the term in y*z^2). Each of these coefficients is a sum of
triple vector products of linear combinations of the vertexes of the
pentahedron.
logodds.m
o = logodds( p ) Calculate the log-odds of a probability, i.e. log( p/(1-p) ). p can be a matrix of any shape. logodds(0) is -Inf, and logodds(1) is Inf. SEE ALSO: logoddsinv.
logoddsinv.m
p = logoddsinv( o ) Calculate the probability corresponding to a log-odds value, i.e. p = 1 ./ (1 + exp(-o)). o can be a matrix of any shape. logoddsinv(-Inf) = 0 and logoddsinv(Inf) = 1. SEE ALSO: logodds.
makedistribution.m
df = makedistribution( pdf ) Convert a probability density function to a cumulative distribution function. pdf is a vector of N elements, being the probability of a random variable being equal to 1:N. df is a vector of the same length, such that df(i) = sum( pdf(1:i) );
matrixToQuat.m
q = matrixToQuat( m ) Convert a column rotation matrix to a row quaternion. Code adapted from http://cache-www.intel.com/cd/00/00/29/37/293748_293748.pdf J.M.P. van Waveren "From Quaternion to Matrix and Back"
mnsd.m
[mn,sd] = mnsd( xx, yy ) Find the mean and standard deviation for the points xx, yy.
moment2distrib1D.m
moment2distrib1D( xx, yy, centre ) XX is a vector of N positions on the X axis. YY is a set of N values, each value being the amount of a quantity at the corresponding element of XX. CENTRE is a point, by default the centroid of the distribution. Consider YY to define the distribution of concentration of a substance over the range of XX, linearly interpolated, and zero everywhere outside the range of XX. Results: MOM2 will be the second moment of that distribution about the centre. CENTROID (if asked for) will be the centroid of the distribution. If CENTRE is omitted it will default to the centroid; in that case MOM2 is the variance of the distribution. TOTAL (if asked for) will be the total quantity of the distribution. See also: meanpos.
mul3n.m
P = mul3n( M, N ) M and N are 3*3*n matrices. P is set to a matrix the same size, such that P(:,:,i) = M(:,:,i)*N(:,:,i). This is more efficient than iterating through the slices when n is at least 20.
ncdf.m
normaliseVector.m
notIn.m
nzdiv.m
v = nzdiv( num, denom, zeroval ) For vectors num and denom of the same shape, this is equivalent to v = num ./ denom, except that where denom is zero, v will be zeroval. zeroval defaults to 0.
oddsratio.m
o = oddsratio( p ) Calculate the odds ratio for a probability p: o = p/(1-p). p can be a matrix of any size. p=1 implies o=Inf. SEE ALSO: oddsratioinv.
oddsratioinv.m
p = oddsratioinv( o ) Calculate the probability for an odds ratio o: p = 1/(1 + 1/o). o can be a matrix of any size. o=Inf implies p=1. SEE ALSO: oddsratio.
otherof3.m
k = otherof3( i, j ) If i and j are distinct digits in the range 1..3, k is the third digit.
quatToMatrix.m
r = quatToMatrix( q ) Convert a quaternion (x,y,z,w) to a rotation column matrix. The quaternion must be a 4-element row vector, with the phase component last. It can also be an N*4 matrix, in which case the result is a 3*3*N array. The quaternions are not checked for being normalised. If the norm is k, the result will be a rotation matrix multipled by k^2.
randsubset.m
Return a random subset of k of the numbers from 1 to n. s will be an array of booleans the same size as n, with k randonly selected elements set to true. This is guaranteed to give exactly k numbers. If what you need is for each number to be chosen independently with probability k/n, just use s = rand(1,n) < k/n.
rotMatFromAngVel.m
angvel is an angular velocity vector. Compute the rotation matrix that represents rotation at that angular velocity for time t (default 1).
rotateVecAboutVec.m
v = rotateVecAboutvec( v, a, theta ) Rotate the 3D vector v about the axis a by angle theta. a is assumed to be a unit vector. v and a must be row vectors. v and a can also be N*3 matrices, and theta an N-element vector: each vector will be rotated about the corresponding axis by the corresponding angle.
saw.m
sinelength.m
l = sinelength( a ) Compute the arc length of a sine wave of amplitude A and period P.
transformGrowthTensor.m
rotD = rotateGrowthTensor( D, J ) D is a rank 2 tensor in row 6-vector form. The result is the transformation of D by J, a 3*3 matrix in column vector form. Otherwise put, D is the expression of the growth tensor in the frame J, and the result is the growth tensor represented in the global frame. This is computed by converting D to a matrix, transforming by J, then converting back to a row 6-vector. If D is an N*6 matrix, this transformation is applied to every row of D.
triangleAltitude.m
vxD = triangleAltitude( vxA, vxB, vxC ) D is the foot of the altitude from A to the line BC. vxA, vxB, and vxC are expected to be row vectors. Any of them may be matrices of more than one row vectors; if more than one is, they must contain the same number of rows, and if any is a single vector it will be replicated the required number of times.
tritrirot.m
r = tritrirot( oldnodes, newnodes, tricellvxs ) OLDNODES and NEWNODES are the old and new positions of a set of N nodes, each an N*3 matrix. TRICELLVXS is a set of M triangles on those nodes, an M*3 matrix. R is set to an M*3*3 array containing M rotation matrices that rotate the old triangles to the same orientation as the new.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Utils\Random
calcdistrib.m
distribPLC.m
distrib = distribPLC ( density ) density is an N*2 matrix of (x,y) coordinates, defining a piecewise linear continuous function. The result is the corresponding piecewise quadratic distribution function, i.e. the integral of the density (but not scaled to have range 0...1). This function is represented as an N*4 matrix. For each tuple (x,y,y',a), (x,y') is the value of the distribution function corresponding to the point (x,y) in the density function, and a expresses the quadratic component between that point and the next: distrib( x+eps ) = y' + y*eps + a*eps^2.
invdistrib.m
polygonDensity.m
dens = polygonDensity( poly ) Construct a density function from a convex polygon. The density function is continuous and piecewise linear. It is represented as an N*4 array. dens(:,1) is the series of x values in increasing order. dens(:,2) is the density function at x. dens(:,3) and dens(4,:) are the y coordinates of the intersections of the line parallel to the y-axis at x with the polygon.
polygonDistrib.m
distrib = polygonDistrib( poly ) Returns a structure representing the distribution function for the x coordinate of a random variable uniformly distributed over the polygon. The polygon is specified as an N*2 matrix.
randBaryCoords.m
bc = randBaryCoords Return random barycentric coordinates yielding a uniform distribution over a triangle. n is the number of coordinate sets to return, defaulting to 1.
randBinCounts.m
r = randBins( binsizes, numpts, uniformise ) Select a random number of points from each of the bins, in proportion to their size. The result is an array the same size as binsizes, containing the number of points that fell into each bin. If uniformise is true (the default is false) then each bin is guaranteed to have n members, where n is one of the two integers on either side of its expected number of members.
randBins.m
r = randBins( binsizes, numpts, uniformise ) Select a random number of points from each of the bins, in proportion to their size. The result is a list, in random order, of which bin each point falls in. If uniformise is true (the default is false) then each bin is guaranteed to have n members, where n is one of the two integers on either side of its expected number of members.
randCDF.m
r = randCDF( cdf, varargin ) Sample according to a CDF. The arguments after the first specify the shape of an array in the same way as for rand(). CDF is a vector of increasing values representing a cumulative distribution function. The result is an array of indexes into CDF. The probability of selecting index N is cdf(N)/cdf(end) if N=1, otherwise (cdf(N) - cdf(n-1))/cdf(end).
randFromDist.m
r = randFromDist( dist, n ) Select N random indexes into a distribution given by DIST. Each index will be chosen with probability proportional to its value in DIST.
randInCircle.m
Uniform distribution in the unit circle.
randInEllipse.m
Uniform distribution on an ellipse of specified semi-axes A and B, centred on the origin.
randInPoly.m
pts = randInPoly( n, poly ) Generate a random set of points uniformly distributed in the polygon POLY in the plane. POLY is an N*2 matrix listing the points of the polygon in anticlockwise order.
randInTriangles.m
[cells,bcs] = randInTriangles( areas, n ) Generate a set of n random points in the plane, uniformly distributed over the triangles (which are assumed to be disjoint). The results are returned in the form of cell indexes and barycentric coordinates.
randPointInCell.m
bcs = randPointInCell( eps ) Return a random point in a triangle in barycentric coordinates, subject to the point not lying close to the sides or medians of the triangle. n is the number of points, defaulting to 1. eps should be in the range 0...0.1.
randcolor.m
c = randcolor( n, hsv1, hsv2 ) Generate n random colors as an N*3 matrix of RGB values. hsv1 and hsv2 are two colors in HSV space. The resulting colours will be distributed in the box of HSV space bounded by these two colours.
randelement.m
randint.m
n = randint( lo, hi, m, n ) Return an m*n array of random integers in the range lo..hi inclusive.
randints.m
r = randints( n, p ) Randomly select a proportion p of the integers from 1 to n. Each integer has a probability p of being chosen; the number of integers selected will therefore average pn but will vary randomly from that figure. At least one integer will always be selected unless n is zero. The integers are returned in ascending order.
randpoly.m
randsubset.m
Return a random subset of k of the numbers from 1 to n. s will be an array of booleans the same size as n, with k randonly selected elements set to true. This is guaranteed to give exactly k numbers. If what you need is for each number to be chosen independently with probability k/n, just use s = rand(1,n) < k/n.
randunitvector.m
v = randunitvector( nvecs, ndims ) Return an nvecs*ndims matrix of random unit row vectors uniformly distributed over the surface of the ndims-dimensional sphere. ndims must be 2 or 3, and defaults to 2. nvecs defaults to 1.
selectPLC.m
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Utils\Structs
addToStruct.m
cellFromStruct.m
checkFields.m
ok = checkFields( s, requiredfields, optionalfields ) Check that the structure s has all the required fields, and nothing else except the optional fields.
checkstructfields.m
u = checkfields( s, mode, varargin ) Check that the set of fields of structure s includes/is included in/equals the fields listed in varargin, according to whether mode is 'incl', 'only', or 'exact'.
compareStructs.m
ok = compareStructs( s1, s2, reportCompatible )
Report on any differences of structure between s1 and s2.
A difference of structure is:
s1 and s2 are of different classes.
s1 and s2 are both arrays, struct arrays, or cell arrays, but have
different shapes.
s1 and s2 are both structs, but have different sets of fields.
s1 and s2 are both structs, but for some field f belonging to both,
s1.f and s2.f have an incompatibility.
The result is true iff there are no incompatibilities.
If reportCompatible is true, compatible components of s1 and s2 will be
reported, otherwise only incompatibilities will be reported.
decoratetree.m
t = decoratetree( t, decor ) Take a tree whose leaves are integers, and make an isomorphic tree whose leaves are the corresponding members of d.
defaultFromStruct.m
s = defaultFromStruct( s, d ) Set nonexistent fields of S in the cellarray FN of field names to the corresponding values of D. FN is optional and defaults to the set of all fields of D.
defaultfields.m
s = defaultfields( s, fieldname, fieldvalue, ... ) Set nonexistent fields of s to the specified values.
emptystructarray.m
fieldvalue.m
v = fieldvalue( s, f ) Set v to s.(f) if s has such a field, otherwise to the default if there is one, otherwise to [].
hashandle.m
invertDictionary.m
s = invertDictionary( a ) a is a cell array of strings. s is set to a structure whose fields are those strings, and whose value for each field is the index of that string in the cell array. The strings must be all different and valid Matlab field names.
invertNameArray.m
loadAddToStruct.m
s = loadAddToStruct( filename, s ) Load a struct from the file, and add its fields to s. Fields not present in s will be added. Fields already present in s will be overwritten if MODE is 'override', and discarded otherwise.
maketree.m
t = maketree( n, s, b ) n = number of items. s = index of first item. b = maximum number of descendants of a node. b1 = maximum number of descendants of the root node (defaults to b).
moveFromStructFields.m
[s,t] = moveFromStructFields( t, varargin ) The variable arguments must be field names of t. Set s to a structure containing those fields of t, and delete them from t.
overridefield.m
s = overridefield( s, fieldtokeep1, fieldstoremove1, fieldtokeep2, fieldstoremove2, ... ) If certain fields of s are nonempty, set certain other fields to be empty, if they exist. Fields not in s are ignored.
printtree.m
printtree( t, indent ) Print a tree whose leaves are integers.
Overloaded methods:
tree/printtree
readstruct.m
newstruct = readstruct( filepath, filename ) Read a Matlab struct from a file. A .stc file stores a Matlab struct in textual form. Each field of the struct is printed, together with the dimensions of its value, on a line of its own. It is followed on subsequent lines by the value of the field. (If the field contains a single, numeric value, then that value is printed on the same line as the field name.) If the field is itself a struct (or struct array) this continues recursively.
reconcileStructs.m
sa = reconcileStructs( varargin ) The arguments are structs of possibly dissimilar structures. The result is an array of structs, consisting of all the given structs in the order they were given, and with any missing fields filled by []. If no arguments are given, an empty struct array of empty structs is returned.
renameStrings.m
s = renameStrings( s, renameindex ) s is either a single string or a cell array of strings. renameindex is a struct mapping strings to strings. Every string in s which is a field name of renameindex is replaced by the value renameindex associates to it.
renameStructFields.m
replacefields.m
safermfield.m
x = safermfield( x, varargin ) Like RMFIELD, but does not throw an exception if a field is not present or if no fields are given.
safestructaccess.m
saveFields.m
[s,r] = saveFields( s, r ) For every field f of r, swap the values of s.(f) and r.(f). It is assumed that every field of r is a field of s.
saveStructFields.m
saveStructFields( filename, s, ... ) Save specified fields from a structure into a file. The field names can be given either as a series of string arguments or as a single cell array of strings. If any specified fields are not present in s they are silently ignored. If no fields are supplied, or none of the specified fields are present, then no file will be written.
setFromStruct.m
s = setFromStruct( s, t, fn ) Set fields of S in the cellarray FN of field names to the corresponding values of T. FN is optional and defaults to the set of all fields of T. Other fields of s are left unchanged.
setFromStructFields.m
s = setFromStructFields( s, t, varargin ) The variable arguments must be field names of t. Set those fields of s to their values in t.
showSort.m
showSort( s ) Show what sort of thing s is, and all of its components recursively.
showStruct.m
showStruct( s ) Print s, and all of its components recursively. There are assumed to be no arrays involved except at the bottom level.
splitstruct.m
varargout = splitstruct( s, varargin ) The optional arguments are cell arrays of strings, which are expected to be field names of the struct s. There should be as many optional output arguments. Each output argument is set to a struct which contains those components of s whose field names are listed in the corresponding optional input argument.
struct2args.m
structFromFile.m
c = structFromFile( filename ) Read the given file, and parse each line into a token followed by a string. Use the token as a field name and the string as the corresponding value. The token will be forced to be a valid Matlab field name by replacing all non-alphanumerics by underscores, and if the result begins with a digit, prefixing 'F_'. If a token occurs multiple times, the values will be stored as a cell array. Blank lines and lines beginning with a # are ignored. If the file cannot be read, an empty struct is returned.
structeq.m
structeq( A, B ) Compare two structs for equality and print a report of the difference. This is a quick and dirty test intended for structs of which every member is a numerical array.
substruct.m
s1 = substruct( s, ... ) Set s1 to a new structure whose fields are those fields of s whose names are given as arguments.
trimStruct.m
s = trimStruct( s, fields ) Remove all fields from s except those in the cell array FIELDS.
writestruct.m
writestruct( dirname, basename, s ) Write the value of s to the file. readstruct(dirname, basename) can be used to read it in again. This does not write any Java objects that the value of s may contain. Other than that, the structure read in by readstruct should be identical to the structure written by writestruct.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Utils\UI
GUIElementPlaceWithin.m
GUIElementPlaceWithin( movable, fixed, isleft, leftmargin, isright, rightmargin ) Place the GUI element MOVABLE relative to the GUI element FIXED. MOVABLE is assumed to be a child of FIXED. If ISLEFT is true, the left side of MOVABLE is placed LEFTMARGIN pixels to the right of the left side of FIXED. If ISLEFT is false, the right side of MOVABLE is placed LEFTMARGIN pixels to the left of the right side of FIXED. Similarly for ISTOP and TOPMARGIN.
GUIElementRelPlace.m
GUIElementRelPlace( movable, fixed, isleft, leftmargin, isright, rightmargin ) Place the GUI element MOVABLE relative to the GUI element FIXED. MOVABLE and FIXED are assumed to be children of the same parent. If ISLEFT is true, the left side of MOVABLE is placed LEFTMARGIN pixels to the right of the left side of FIXED. If ISLEFT is false, the right side of MOVABLE is placed LEFTMARGIN pixels to the left of the right side of FIXED. Similarly for ISTOP and TOPMARGIN.
XrelPosUIElement.m
relPosUIElement( uihandle1, uihandle2, relhoriz, relvert ) Position a UI element uihandle2 within uihandle1. If relhoriz is positive, it is 1 more than the desired distance from the left edge of uihandle1 to the left edge of uihandle2. If negative, it is similarly applied to the right hand sides. If zero, no horizontal repositioning is done. relvert similarly applies to vertical repositioning, with positive values applying to the bottom edge and negative to the top edge.
addMenuHelp.m
addMenuHelp( hm, m, helptexts, separator ) hm is a handle to a help menu, to which an item should be added to provide help for the menu or menu item m. If m is a menu item, the correspomnding help menu item will bring up a dialog showing some helpful text for that item. If m is a menu (i.e. it has children), then a menu will be created whose first item will be the help item for m, and whose remaining items or submenus will provide the help for the children of m. helptexts is a struct which maps the tag of each menu or menu item to its help text. If separator is true, a separator should appear before the help menu item.
addUserData.m
ud = addUserData( h, fieldname, value, fieldname, value, ... ) Set fields of the UserData attribute of the handle h. The complete UserData struct is returned.
addpathif.m
added = addpathif( d ) As addpath(d), but returns true if and only if d was not already on the path. If d is already on the path, addpath(d) is still called, as this has the effect of moving d to the beginning of the path.
alignPics.m
askForFloat.m
i = askForFloat( title, prompt, dflt, bounds ) Put up a modal dialog asking the user to enter a floating point number. The dialog will have the specified title. The PROMPT string will be displayed as static text above the text-entry box. DFLT is the initial contents of the text-entry box. The result will be [] if the user cancelled the dialog (by clicking the "Cancel" button, clicking the close box, or hitting escape). Otherwise, it will be the final contents of the text-entry box, interpreted as a floating-piont number. If it is invalid, the dialog will be re-opened. BOUNDS is a pair of numbers, a lower and upper bound of acceptable answers. If omitted, it defaults to [-Inf Inf].
askForInt.m
i = askForInt( title, prompt, initval ) Put up a modal dialog asking the user to enter an integer. The dialog will have the specified title. The PROMPT string will be displayed as static text above the text-entry box. INITVAL is the initial contents of the text-entry box. The result will be [] if the user cancelled the dialog (by clicking the "Cancel" button, clicking the close box, or hitting escape). Otherwise, it will be the final contents of the text-entry box, interpreted as an integer. If it is invalid, the dialog will be re-opened.
askForNumlist.m
[nums,ok] = askForNumlist( title ) Put up a dialog that asks the user for a list of numbers. TITLE is the title of the dialog. If the user types something syntactically invalid, the dialog will be re-presented. If the user cancels the dialog, OK will be false and NUMS will be empty, otherwise OK will be true and NUMS will be the list of numbers. Matlab A:B and A:B:C syntax is supported: these will be expanded out to the equivalent series of values.
askForString.m
[s,ok] = askForString( title, prompt, initval ) Put up a modal dialog asking the user to enter a single line of text. The dialog will have the specified title. The PROMPT string will be displayed as static text above the text-entry box. INITVAL is the initial contents of the text-entry box. The result S will be empty and OK will be false if the user cancelled the dialog (by clicking the "Cancel" button, clicking the close box, or hitting escape). Otherwise, S will be the final contents of the text-entry box and OK will be true. All arguments are optional and default to the empty string.
askForStringDlg.m
Begin initialization code - DO NOT EDIT
askForText.m
[x,ok] = askForText( title, rubric ) Present a modal dialog to request some multiline text from the user. TITLE will be used as the title of the figure and RUBRIC is a string that will appear within the figure at the top. x will be returned as a one-dimensional character array containing newline characters to separate the lines. Trailing spaces before newlines will have been removed. OK will be true if the user clicked the OK button, false if the user cancelled the dialog. In the latter case X will be empty.
autoSubMenus.m
autozoomcentre.m
camParams = autozoomcentre( camParams, bbox, zoom, centre ) Adjust the camera params so as to look at the centre of the bbox (if centre is true) and have the bbox fill the field of view (if zoom is true). bbox is a 6-element vector as returned by axis().
axissize.m
basicLineStyle.m
[lw,ls] = basicLineStyle( width ) Because Mathworks don't think zero is a number.
bgColorPick.m
callbackName.m
centreDialog.m
Set the position of the dialog - centered on the callback figure if available, else, centered on the screen
checkMenuItem.m
checkMenuLengths.m
ok = checkMenuLengths( mh, maxlen ) Check that neither the menu mh nor any of its descendants has more than maxlen children.
checkSlider.m
checkTerminationKey.m
closeDialog.m
collectDialogData.m
complain.m
confirmDialog.m
ok = confirmDialog( format, varargin ) Put up a two-button dialog to ask the user to confirm some operation. The text of the dialog will be the result of sprintf( format, varargin ). The buttons will be labelled 'OK' abnd 'Cancel'.
confirmOverwrite.m
connectTextAndSlider.m
connectTextAndSlider( hText, hSlider, name, callback )
Connect the text item and the slider, so that changes to either will
show up in the other and invoke the callback.
The callback should expect to be called thus:
callback( hObject, name, x )
where hObject is the handle to the slider and x is the value, of type
double.
NAME and CALLBACK can be omitted.
defaultButtonDownFcn.m
defaultButtonDownFcn( hObject, eventData ) Install this into any graphics object that should pass button down events to its parent. IMHO, this ought to be the default behaviour, but the default behaviour is to ignore the event. For objects that process some mouse-down events but not others, call this function from that object's ButtonDownFcn when it decides it does not want to handle the event itself.
defaultScaleBarUnit.m
deleteMenuItems.m
dialogOutputFcn.m
Get the result of the dialog.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Utils\UI\dialoglayout
abutUIElement.m
abutUIElement( uihandle1, uihandle2, isHoriz, distance ) Position uihandle2 relative to uihandle1. If isHoriz is true, it is positioned on the same horizontal line, otherwise the same vertical line. alignMode = 0 if it is to be centred, -1 if left/bottom edges aligned, 1 is right/top edges aligned. distance is the size of the gap between them.
buildFigure.m
WORK IN PROGRESS
buildRSSSdialogFromFile.m
[result,s] = buildRSSSdialogFromFile( fn, initvals, userdata, initfun ) Create a dialog from the dialogspec contained in the file called fn. Fill it with values from initvals (a struct mapping item tags to values). Perform the (modal) dialog and return the result. result is empty if the user cancelled the dialog (by hitting a cancel button, hitting the escape key, or clicking the close box on the dialog). Otherwise, result is a structure mapping item tags to their values when the user closed the dialog. s is a structure describing the dialog and should be ignored. It exists only for debugging purposes.
buildRSSSstructdialog.m
compactRSSSSpace.m
computeIntervals.m
s = computeIntervals( s )
s is a tree structure whose nodes may each have these attributes:
natsize: natural size (a number)
actualsize: actual size (a number)
position: two numbers: startpos and length.
align: 'min', 'max', 'mid', or 'fill'.
When s is given, none of the position attributes are set. All leaves
have a natsize and the root has a maxsize.
convertStringsToHandles.m
items = convertStringsToHandles( parent, items )
items is a nested cell array of strings. This procedure crawls over
the structure, replacing strings that it recognises by GUI handles
which it creates. The recognised strings are:
'OK'
'Cancel'
'OKCancel'
all of the standard uicontrol type names
These are recognised when they occur as the first child of a parent
node. For the first three, the other children are also processed. For
the last, the other children are interpreted as its parameters.
createDialog.m
figure_SpaceItems.m
figure_SpaceItems( parent, items, bbox, vn, hsep, vsep, hmargin, vmargin ) WORK IN PROGRESS parent is a panel or a figure. items is an array of handles to UI items. The procedure lays out the items within the parent in a regular grid according to the remaining parameters. bbox is the bounding box of an area within the parent that the items are to be placed. If it is empty, it defaults to the full size of the parent. hn is the number vertically. vn is the number vertically. hsep is the horizontal space between items. vsep is the vertical space between items. hmargin is the horizontal space between items and the bounding box. vmargin is the vertical space between items and the bounding box.
fillRSSSdefaults.m
forceRSSSPosition.m
getLayoutStructItem.m
getRSSSFromFile.m
getRSSSPositions.m
handleInteriorSize.m
insetPosition.m
pos = insetPosition( pos, inset ) POS is an array [x y w h]. INSET is an array [left right top bottom]. The result is a position which is inset from the given position by the given amount on each edge.
isgroupinghandle.m
layoutItem.m
layoutSkeleton.m
listGUIObjects.m
makeCancelButton.m
h = makeCancelButton( fig, pos ) Make a standard Cancel button in the given figure at the given position. FIG can also be a uipanel handle.
makeEditableText.m
h = makeEditableText( fig, pos, tag, inittext, multiline ) Make a standard editable text object.
makeGeneralDialog.m
makeOKButton.m
h = makeOKButton( fig, pos ) Make a standard OK button in the given figure at the given position. FIG can also be a uipanel handle.
makeStaticText.m
modelessRSSSdialogFromFile.m
[fig,s] = modelessRSSSdialogFromFile( fn, initvals, userdata, initfun ) Perform a modeless dialog. The arguments are the same as those for performRSSSdialogFromFile. FIG is a handle to the dialog window. S (for debugging purposes) contains a struct describing the dialog layout. See also: performRSSSdialogFromFile.
normaliseGUIItemSize.m
normaliseTag.m
tag = normaliseTag( tag )
Take a string from which a GUI object tag is to be made, and normalise
it by:
* Converting to lower case.
* Deleting everything other than lower case letters, numbers,
underscore, and spaces.
* Deleting leading and trailing spaces.
* Replacing all remaining spaces by underscores.
If tag is a cell array, each member will be normalised.
parseRSSS.m
s = parseRSSS( ts ) Parse the token stream ts, returning a structure s.
performDialog.m
performRSSSdialogFromFile.m
[result,s] = performRSSSdialogFromFile( fn, initvals, userdata, initfun ) Perform a modal dialog. The layout of the dialog is specified in the text file FN. Initial values can be supplied by the struct INITVALS. USERDATA will be stored (together with a struct defining the dialog layout -- this is only for debugging purposes) in the 'Userdata' field of the dialog window. INITFUN is a function which will be called after constructing the dialog but before making it visible, in order to make any changes to it that cannot be done by setting initial values and storing user data. It receives the window handle as its only argument. All arguments except the first are optional. RESULT will be empty if the user cancels. Otherwise, it will be a struct mapping the tags of all editable GUI elements to the corresponding values. S (for debugging purposes) contains a struct describing the dialog layout. See also: modelessRSSSdialogFromFile.
printSetupCode.m
rectifyRSSSPositions.m
Pass 1: Compact all space.
setPositionsInDialog.m
setRSSSColors.m
s = setRSSSColors( s )
setRSSSPositions.m
showGUIPositions.m
testPerformDialog.m
dirnames.m
names = dirnames( filename ) Like DIR, but return a cell array of just the names.
displayFileInDlg.m
displayTextDialog.m
displayTextDialog( title, msg ) Present a modal dialog displaying some text to the user. TITLE will be used as the title of the dialog and MSG is a string that will appear within the dialog. The user may hit return or escape to dismiss the dialog.
displayTextInDlg.m
dragviewButtonDownFcn.m
dragviewButtonDownFcn( hObject, eventData ) Installing this as the ButtonDownFcn for an axes object or its children will cause a click on the object to produce panning, zooming, or trackball-like behaviour when the mouse is dragged. This routine temporarily stores all the information it needs to process the mouse movement, in the field 'clickdragData' of the guidata of the figure. The field is deleted when the mouse button is released. As a side-effect, all of the camera mode properties of the axes are set to manual. There is more than one way to map mouse movement to rotation, and the choice is a matter of design. Three mappings are implemented, and the choice can be specified by setting the 'trackballMode' field of guidata. 'global' (the default) maps trackball coordinates [x,y] to a rotation about an axis perpendicular to that vector in the (cameraright,cameraup) plane, by an amount proportional to the length of the vector. 'local' maps incremental motion of the mouse to incremental rotation in the same way. 'upright' maps trackball coordinates [x,y] to azimuth and elevation, maintaining the camera up vector equal to [0 0 1]. This is equivalent to the trackball mode available from the standard camera toolbar, except that the scaling may be different. Global and Upright mode have the advantage that mouse positions are uniquely mapped to rotations: moving the mouse back to its starting point restores the axes to its original orientation. Local mode has the advantage that the current rotation axis is always perpendicular to the current mouse velocity. There is no mapping of trackball data to axes rotation that allows both of these. The scaling factor is currently set so that movement by a distance equal to the smaller of the width and height of the axes object rotates it by 2 radians.
dumpFigure.m
dumpFigure( fig ) Print an indented list of the contents of the figure.
edittextCreateFcn.m
enableGUIitem.m
enableHandle.m
exitDialog.m
figureaxes.m
ax = figureaxes( fig, legends ) FIG is a figure handle. Return a list of all the children of FIG that are axes handles. If LEGENDS is true (the default is false) then legend axes will be included.
fillAxes.m
fillAxes( h, color ) Clear the axes object h and fill it with the given colour.
findBadCheckbox.m
findinpath.m
x = findinpath( d, p ) Returns 0 if d is not a directory on the path p, otherwise the index of d's position in p. If p is not supplied the current command path is used.
firstOnPath.m
x = firstOnPath() Return the first directory on the Matlab command path. Returns the empty string if the path is empty (which should never happen).
forceMenuSeparator.m
forceMenuSeparator( h ) This is a workaround for a bug in Matlab 2010a on Mac OS, whereby in some circumstances, menu separators fail to appear even though the 'Separator' attribute of the menu handle is properly set.
forcepixelunits.m
fullpath.m
pname = fullpath( fname, relto ) Find the full path name of a given file name. If the filename is relative, it is taken to be relative to the directory relto, which defaults to the current directory.
genpathnodot.m
s = genpathnodot( d ) Like genpath, except that the argument is required, and directories whose name begins with a dot are excluded.
getCameraParams.m
getCheckedSubmenu.m
[h,n] = getCheckedSubmenu( menuhandle ) Return the handle and position of the first child of menuhandle that has a checkmark. If there are none, return zero and the empty list.
getDialogItemData.m
getDoubleFromDialog.m
getDoubleFromString.m
getFontDetails.m
fd = getFontDetails( h ) Find the font properties of the graphics handle h. The result is a structure with the fields FontName, FontUnits, FontSize, FontWeight, and FontAngle. All values are strings. Missing fields are returned as empty strings.
getIntFromDialog.m
getIntFromString.m
getMenuChildren.m
c = getMenuChildren( h ) Return a list of the children of h in the same order they appear in the menu.
getMenuIndexFromLabel.m
getMenuLabelFromIndex.m
getMenuLabelsFromIndex.m
getMenuSelectedIndex.m
getMenuSelectedLabel.m
getPatchHit.m
n = getPatchHit( patchHandle, hitPoint ) Given the hitPoint as returned by get( gca, 'CurrentPoint' ) and a patch handle, determine which polygon was hit. Matlab must know this, in order to have detected a hit on the patch, but I can't find any way of getting this information. The test is performed by determining which of the polygons enclose the line, and then taking the one whose centroid is closest to the near end of the line.
getRootHandle.m
getSelectionType.m
selectionType = getSelectionType( hitObject ) Get the mouse/keyboard modifier information for a click on an object contained in an axes contained in a figure. We have to hunt up the chain of parents to find the object that has the SelectionType information.
getViewWidth.m
getsubdirs.m
dirs = getsubdirs( dir, ... ) Return the names of the directory dirname and all its subdirectories, except for directories matching any of the regexp patterns given as subsequent arguments. The result is a single string in which the names of all the directories are concatenated, separated by a ':' character. This string can be passed to the path() command, to add all of these directories to the MATLAB command path.
groupRadioButtons.m
handleSliderToText.m
handleTextToSlider.m
inputFilterspec.m
filters = inputFilterspec( extensions, allowall ) Given a cell array of file extensions (which must NOT include the initial "."), construct a filterspec for use with uigetfile. If allowall is given, it specifies whether to include the 'All files' option. The default is to include it. If there is more than one extension in the list, the 'All suitable' option will be included as the first filter.
insertDefaultsInDlg.m
installDefaultButtonDownFcn.m
installDefaultButtonDownFcn( h ) Install a default ButtonDownFcn into h and all of the children of h, recursively. defaultButtonDownFcn transmits mouse-down events to the first ancestor that has a nonempty ButtonDownFcn property.
isMenuSelectedLabel.m
isPathPrefix.m
isprefix = isPathPrefix( shorter, longer )
SHORTER and LONGER are paths to files. This procedure
determines whether SHORTER is a path prefix of LONGER.
This is true if SHORTER is a prefix of LONGER, and either SHORTER ends
with a file separator ('/' or '\'), or the next character of LONGER,
if there is one, is a file separator.
isabsolutepath.m
isabs = isabsolutepath( filename ) Determine whether the filename is an absolute pathname or not. It is deemed to be absolute if it begins with a slash, a backslah, or /[A-Za-z]:/.
ischeckedMenuItem.m
labelAxes.m
lightAxes.m
lightAxes( theaxes, turnLightOn ) Turn lighting for the given axes object on or off. To turn the light off, every child object of type 'light' is deleted. To turn it on, if there is already a child object of type 'light', nothing is done. Otherwise a light is created with default properties.
magicButtonBackgroundColor.m
Magic value that makes buttons take on the native platform appearance (at least on a Mac).
makeDirMenu.m
h = makeDirMenu( parent, dirstruct, readonly, callback )
Take a structure returned by findProjectDirs and make a hierarchy of
menus, as a child of the parent menu.
The userdata field of each menu item will contain these fields:
fullname: the full pathname to the directory
basename: the base name of the directory
readonly: a boolean to indicate whether projects within this
directory should be treated as read-only.
makePackedMenu.m
makePackedMenu( parent, position, menudata, maxmenulength, mintopmenulength ) Create a tree of submenus of the given parent menu. MENUDATA is an array of structs, one for each of the menus to be created. These structs contain the parameters to be supplied to uimenu for each menu. They must define the 'Label' property and may define any others; typically they will define at least the 'Callback' property. All of them must define the same set of parameters. If a parameter is needed for some menu items but not others, provide an empty value or an appropriate default value for those where it is not needed. The maximum length of any of the created menus will be MAXMENULENGTH. PARENT is the top-level menu into which the items will be inserted, starting at POSITION. PARENT may already have other menu items; in this case the number of top level items inserted will be no more than will bring the total length of the parent up to MAXMENULENGTH, unless this would result in fewer than MINTOPMENULENGTH top-level items, in which case MINTOPMENULENGTH top-level items will be inserted.
menuPath.m
modalOpeningFcn.m
Choose default command line output for timeunitDlg
mygetframe.m
f = mygetframe( theaxes ) Like getframe(), but brings the axes to the front.
myquiver3.m
MYQUIVER3 3-D quiver plot. This differs from the standard quiver3 in the following ways: 1. The origins and velocities are given as row vectors, or matrices of the same. 2. It takes an additional argument NORMALS, which should follow the velocity argument. The arrowheads will be drawn in a plane perpendicular to the corresponding normal vector. 3. It takes an additional argument HEADSIZE specifying the size of the arrowheads as a proportion of the size of the shaft. The handle returned by quiver3 has a MaxHeadSize attribute, but I find there appears to be a maximum size that it allows, irrespective of the value requested. 4. It takes an additional argument AXISHANDLE. 5. It does not return a quiver object. Instead, it returns an N*3 array of handles to line objects. The three handles in each row are the shaft and two barbs of a single arrow.
newlistdlg.m
This is a reimplementation of the MATLAB listdlg() using my dialog layout
system. The arguments are identical to those for listdlg():
'ListString' cell array of strings for the list box.
'SelectionMode' string; can be 'single' or 'multiple'; defaults to
'multiple'.
'ListSize' [width height] of listbox in pixels; defaults
to [160 300].
'InitialValue' vector of indices of which items of the list box
are initially selected; defaults to the first item.
'Name' String for the figure's title; defaults to .
'PromptString' string matrix or cell array of strings which appears
as text above the list box; defaults to {}.
'OKString' string for the OK button; defaults to 'OK'.
'CancelString' string for the Cancel button; defaults to 'Cancel'.
nums2string.m
s = nums2string( x, fmt ) Format a list of numbers to a string, using FMT as the format for each number.
numsDlg.m
Begin initialization code - DO NOT EDIT
offsetCameraParams.m
camParams = offsetCameraParams( camParams, eyeoffset )
opendir.m
[ok,msg] = opendir( dirname ) Open the named directory on the desktop, by default the current working directory. This works on Mac OS X and Windows systems. It might work on Linux or other Unix systems, but this has not been tested. If dirname is a relative path name, it will be interpreted relative to the current working directory. If dirname is the name of a file, its containing directory will be opened. If dirname does not exist, no action is taken. status will be 0 for success and nonzero for failure. If nonzero, then msg will be an error message. If the msg parameter is not asked for, the message will be written to the Matlab console.
openmdir.m
success = openmdir( mname ) Open an Explorer window for the directory containing the given Matlab command. If the return argument is specified, it will be 1 for success and 0 for failure. If it is not, then on failure an error message will be written to the Matlab console.
outputFilterspec.m
filters = inputFilterspec( extensions ) Given a cell array of file extensions (which must NOT include the initial "."), construct a filterspec for use with uiputfile.
packmenu.m
packmenu( menuhandle ) This takes a handle to a menu and reorganises it so that no submenu contains more than maxitems items.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\Utils\UI\projects
clearImageData.m
closeProject.m
makeNewProject.m
queryDialog.m
result = queryDialog( numbuttons, title, format, varargin )
Show a modal dialog displaying the result of sprintf( format,
varargin{:} ). The title of the dialog will be TITLE.
numbuttons must be 1, 2, or 3, and is the number of
buttons in the dialog. Their labels will depend on the number of
buttons:
1 button: OK
2 buttons: OK, Cancel
3 buttons: Yes, No, Cancel.
Alternatively, the first argument can be a cell array of 1, 2, or 3
strings. These strings will specify the labels of the buttons.
If title is empty, it will default to a string depending on the number
of buttons: 'Alert', 'Confirm', or 'Query' respectively.
The result is the index of the selected button. Hitting return selects
the first button. Hitting escape selects the last button (even if that
is the same as the first button). Closing the dialog returns 0 (this
should be taken to be equivalent to selecting the last button).
The text of the dialog can have any length. The dialog will
automatically be resized to fit.
querydlg.m
QUERYDLG M-file for querydlg.fig
QUERYDLG, by itself, creates a new QUERYDLG or raises the existing
singleton*.
H = QUERYDLG returns the handle to a new QUERYDLG or the handle to
the existing singleton*.
QUERYDLG('CALLBACK',hObject,eventData,handles,...) calls the local
function named CALLBACK in QUERYDLG.M with the given input arguments.
QUERYDLG('Property','Value',...) creates a new QUERYDLG or raises the
existing singleton*. Starting from the left, property value pairs are
applied to the GUI before querydlg_OpeningFunction gets called. An
unrecognized property name or invalid value makes property application
stop. All inputs are passed to querydlg_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
removeUserDataFields.m
restoreColor.m
restoreColor( h ) Set the BackgroundColor of h to the value saved in the UserData.
safeSetHandleFields.m
safeSetHandleFields( h, s ) H is a graphics handle, S is a struct, and FNS is a set of fieldnames (which defaults to the set of all fieldnames of S). For every field that occurs in FNS, S, and H, this procedure sets that field of H to its value in S. All error conditions are ignored and there is no return value. Case is ignored, e.g. fontweight and FontWeight will both be recognised as valid fields of a text item.
saveColor.m
saveColor( h ) Store the foreground and background color attributes of h in its UserData, so that if we have occasion to temporarily change the colors, we can later restore the original values.
scalebarsize.m
selectButton.m
selectButton( onButton, buttons ) onButton is a radio button or checkbox and buttons is an array of buttons of checkboxes which includes onButton. None of the buttons should belong to a button group. This routine creates the effect of a button group: onButton is set to on and all the other buttons are set to off. The result is the index of onButton in buttons. If onButton is not in the list, the result is zero. All of the buttons in such a pseudo-group should have the same callback function. This function should call SELECTBUTTON, passing the current handle as the first argument and a list of all the buttons in the group as the second. The result tells it which button was clicked. If the result is zero, this means that the currently selected button was clicked, and was a radio button. No action should be taken. If the result is negative, this means that the currently selected button was clicked, and was a checkbox, whose index is minus the return value. See also: WHICHBUTTON
selectGraphicObject.m
selectMenuByLabel.m
selectMenuChoice.m
selectMenuChoice( hObject ) Make the menu item hObject be the only checked item in its parent menu.
setCameraParams.m
fprintf( 1, 'setCameraParams pos [%f %f %f] tgt [%f %f %f] up [%f %f %f] ang %f\n', ...
cp.CameraPosition, cp.CameraTarget, cp.CameraUpVector, cp.CameraViewAngle );
setDoubleInTextItem.m
setGUIElementColor.m
setGUIElementColor( h, c ) Sets the colour of the GUI element H to color C, without caring whether the relevant field is called 'Color' or 'BackgroundColor'.
setGUISizes.m
setManualCamera.m
setMenuHighlight.m
hadhighlight = setMenuHighlight( menuhandle, sethighlight ) Highlight or dehighlight a menu item. If it has no children do this by setting or removing the checkmark. If it has children, do this by adding or removing the string '* ' at the beginning of the menu label. We do this because checkmarks cannot be applied to menu items that have children. The 'Checked' attribute can be set but has no visual effect. We cannot do highlighting by changing the text style or colour of a menu or menu item, because Matlab does not support it, and the unsupported way of doing it (by using HTML in the label) works only when menus are implementd by Java Swing, which at least on Mac OS they are not.
setMenuItemStyle.m
setMenuItemItalic( menuhandle, italic )
Set or remove the italic, bold, or underline properties of the given
menu handle. The style is a string whose characters mean:
'I' italic
'i' nonitalic
'B' bold
'b' nonbold
'U' underline
'u' no underline
'H' coloured (colour is hard-wired in this procedure)
'h' uncoloured (black)
Type style settings for Matlab menu items are performed by using HTML
in the Label property of the menu handle. Your menu callback for the
item should therefore not depend on the label to determine which menu
item it is.
The new label and the old label are returned.
setPixelUnits.m
setShowHideMenuItem.m
setShowHideMenuItem( h, v ) For a menu item having a label of the form 'Show ...' or 'Hide ...', set it to 'Hide ...' if v is 1, otherwise 'Show ...'. See also: toggleShowHideMenuItem, valueShowHideMenuItem.
setSliderAndText.m
setTextAndSlider.m
setTextAndSlider( h, x ) H is either a text object or a slider, of a pair which are linked to each other. x is a double. The slider is given the value of x, and the text object is given the value as a string.
setViewWidth.m
setVisibility.m
showHandleInfo.m
simpleExceptionMessage.m
sliderToTextCallback.m
sliderToTextCallback( hObject, eventdata )
standardResize.m
standardResize(hObject, handles)
hObject handle to GFTwindow (see GCBO)
handles structure with handles and user data (see GUIDATA)
This is a figure resize callback routine. It assumes that the figure
consists of two parts: a control panel of fixed size, and a picture
which is to be automatically resized to take up maximum space in the
window. The picture has horizontal and vertical scroll bars, and a
text area below the latter: all of these are to be moved and resized
along with the picture.
Handles is assumed to have the following fields:
initmainpanelposition:
A 4-element array containing the initial position and size of
the control panel.
margin:
The distance between the control panel and the top and left
edges of the window.
picturepanel
Handle to the panel containing the picture.
picture, legend, elevation, roll, azimuth, report:
Handles for the picture, the vertical scroll bars, the
horizontal scroll bar, and the text area respectively.
stereoPairAxes.m
stereoPairAxes( ax1, ax2, vergence, trackball ) Make the two axes objects into a stereo trackball pair, by storing in the guidata of each a reference to the other and the angle of convergence. ax1 is assumed to be the left eye view and ax2 the right eye view, in which case vergence should be positive. The trackball argument is optional and defaults to false. If true, trackballButtonDownFcn is installed as the ButtonDownFcn in both axes objects and all their children. Clicking and dragging on either window will rotate both views together. If you only want trackball functionality part of the time -- for example, only when the user does a control-click-drag -- then you should not install it here, but call trackballButtonDownFcn from your own ButtonDownFcn when you detect that trackball behaviour is required.
stereoTransfer.m
stereoTransfer( varargin )
Set the viewpoint of one axes to that of another, rotated about the
camera up vector.
stereoTransfer(AX) will transfer the view of the axes AX to the axes
contained in AX's guidata element stereodata.otheraxes, rotated by
stereodata.vergence (an angle in radians).
stereoTransfer() is equivalent to stereoTransfer(gca).
stereoTransfer( AX1, AX2, VERGENCE ) will transfer the view from AX1 to
AX2, offset by the angle VERGENCE.
stereoTransfer( AX, POSITION, TARGET, UP, VERGENCE ) will set the view
of the axes AX to the result of offsetting the view by a rotation
about UP by VERGENCE, from the view specified by the given camera
POSITION, TARGET, and UP vectors.
In all cases, vergence must be an angle in radians. If the view is
being transferred from the left eye to the right eye, vergence should
be positive. If the distance between someone's eye is E and they are
a distance D from the screen, vergence should be E/D radians.
The resulting view is returned in the output arguments.
svnrevision.m
[revs,dates] = svnrevision( dirname, recurse )
Find the SVN revision number and date of revision of a directory, and
optionally, all its subdirectories. In the latter case, if there is
more than one revision number, the list of revision numbers and dates
found will be returned in reverse chronological order, with duplicates
omitted. revs(1) is therefore always the most recent revision found,
and dates{1} the most recent revision date.
If a directory is not under SVN control, revs is 0 and dates is .
In a recursive search, subdirectories whose name begins with '.' are
ignored. DIRNAME itself can begin with a '.' and will be searched.
If a directory is not under SVN control, its subdirectories will still
be searched.
WARNING AND IMPLEMENTATION:
The documentation for SVN explicitly denies offering any way to read
this information, so I have had to discover where it resides by trial
and error. Since it is undocumented, my code might break in future
revisions of SVN, and I cannot be sure that it will work under all
circumstances in the current version of SVN.
The method is to look in the file .svn/entries. The third token in
this file is the revision number, and the sixth is the date in Zulu
format.
Richard Kennaway 2011.
testAndClear.m
textToSliderCallback.m
textToSliderCallback( hObject, eventdata )
toggleCheckedMenuItem.m
toggleShowHideMenuItem.m
v = toggleShowHideMenuItem( h ) For a menu item having a label of the form 'Show ...' or 'Hide ...', switch from one state to the other. Return 1 if the old state was 'Show ...', otherwise 0. See also: setShowHideMenuItem, valueShowHideMenuItem.
trackballButtonDownFcn.m
trackballButtonDownFcn( hObject, eventData ) Installing this as the ButtonDownFcn for an axes object or its children will cause a click on the object to produce trackball-like behaviour when the mouse is dragged. This routine temporarily stores all the information it needs to process the mouse movement, in the field 'trackballData' of the guidata of the figure. The field is deleted when the mouse button is released. As a side-effect, all of the camera mode properties of the axes are set to manual. There is more than one way to map mouse movement to rotation, and the choice is a matter of design. Three mappings are implemented, and the choice can be specified by setting the 'trackballMode' field of guidata. 'global' (the default) maps trackball coordinates [x,y] to a rotation about an axis perpendicular to that vector in the (cameraright,cameraup) plane, by an amount proportional to the length of the vector. 'local' maps incremental motion of the mouse to incremental rotation in the same way. 'upright' maps trackball coordinates [x,y] to azimuth and elevation, maintaining the camera up vector equal to [0 0 1]. This is equivalent to the trackball mode available from the standard camera toolbar, except that the scaling may be different. Global and Upright mode have the advantage that mouse positions are uniquely mapped to rotations: moving the mouse back to its starting point restores the axes to its original orientation. Local mode has the advantage that the current rotation axis is always perpendicular to the current mouse velocity. There is no mapping of trackball data to axes rotation that allows both of these. The scaling factor is currently set so that movement by a distance equal to the smaller of the width and height of the axes object rotates it by 2 radians. A different value can be set by setting the 'trackballScale' field of the figure's guidata to the requried value.
trycd.m
olddir = trycd( newdir )
Like CD, but prints a warning if it fails instead of raising an
exception. If it fails, olddir will be set to the empty string.
See also:
CD
tryget.m
tryget( h, varargin ) Get attributes of a handle. Do not crash if any of them do not exist.
tryset.m
ok = tryset( h, varargin ) Set attributes of a handle. Do not crash if anything goes wrong, just return a boolean to indicate success or failure.
tryuncd.m
uiputdir.m
dirname = uiputdir( startpath, title ) Provide a way for the user to create a new directory. uigetdir can be used for this purpose, but we have found that users find the resulting dialog confusing. uiputdir as defined here performs two successive dialogs: the first to obtain a name for the directory that should be created, and the second to select a directory within which to create it. If the directory to be created already exists, the user will be asked if they want to use it, or to try again with a different name. startpath is the directory from which the directory-selection dialog will start. prompt1 is the prompt displayed in the dialog asking the user for the name of the new directory. prompt2 is the prompt displayed in the dialog asking the user to select a parent directory. On Mac OS, the latter dialog does not display prompt2 anywhere. All arguments are optional. startpath defaults to the current directory, and prompt1 and prompt2 default to the empty string.
validateGUI.m
ok = validateGUI( h ) Make validity checks of the GUI element h.
valueShowHideMenuItem.m
v = valueShowHideMenuItem( h ) For a menu item having a label of the form 'Show ...' or 'Hide ...', return 0 if the label is 'Show ...', otherwise 1. This may seem to be the opposite of what one would expect, but remember that when the menu command says 'Hide', the last menu command that the user performed was 'Show', and vice versa. See also: setShowHideMenuItem, toggleShowHideMenuItem.
viewControlIcon.m
whichButton.m
whichButton( buttons ) buttons is an array of radio buttons. None of the buttons should belong to a button group. This routine creates the effect of a button group: it returns the index of the first button that is set to on, or zero if there is no such button. See also: SELECTBUTTON
adddirstopath.m
dirs = adddirstopath( dir, ... ) Add dir and all its subdirectories to the path, except for directories matching any of the patterns given as subsequent arguments.
addstrings.m
s = addstrings( s, ss ) Concatenate the strings in the cell array ss onto the end of s, each with an added newline.
allfileparts.m
allmin.m
[y,i] = allmin( x ) Return the minimum value of the vector x, and a list of indexes of all elements of x having that value.
alphabins.m
binsizes = alphabins( names, maxbin ) Result is list of indexes saying which bin each name belongs to. Names are assumed already sorted. No multi-level hierarchy: either no bins required or one level of binning.
appendFileToStream.m
ok = appendFileToStream( fid, filename ) Append the contents of the named file to the open output stream. The result is true if the operation succeeds, false otherwise. No error messages are generated if the operation fails.
array2cellarray.m
ca = array2cellarray( a )
a is an N*2 array which is assumed to be sorted by its first column.
The result is a cell array of arrays such that ca{i} is an array of all
values of a(:,2) for which the corresponding element of a(:,1)==i.
binsearchall.m
i = binsearchall( vec, vals ) Apply binsearch to vec and every member of the array vals. The result is a matrix the same shape as vals.
binsearchupper.m
i = binsearchupper( vec, val ) Find that i such that vec(i-1) < val <= vec(i), where vec(0) and vec(length(vec)) are notionally considered to be -Inf and +Inf. val may be a vector, in which case i will be a column vector of the same length. THIS FUNCTION SHOULD BE DELETED, AND EVERYWHERE THAT THIS FUNCTION IS CALLED SHOULD BE REVISED TO USE MATLAB'S binsearch INSTEAD. THE MATLAB FUNCTION IS DEFINED DIFFERENTLY TO THIS ONE, SO EVERY CALL OF THIS ONE MUST BE CHANGED ACCORDINGLY.
blueRedCmap.m
boing.m
boolchar.m
canUseGPUArray.m
canonicalNewlines.m
s = canonicalNewlines( s ) Force Unix newline convention: replace crlf and cr by lf.
capitalise.m
checkallints.m
ok = checkallints( msg, list, max ) Check that list is 1:max. Complain if not. List is expected to be a list of integers resulting from a call of unique(), i.e. sorted with no repetitions. This implies that it is necessary and sufficient that it have the right length, and if nonempty, begins with 1 and ends with max.
colorDistance.m
d = colorDistance( rgb1, rgb2 ) A very crude estimate of psychological color distance.
colorStep.m
cmap = colorStep( c1, c2, n, open1, open2 ) Construct a colour map with n elements, going from c1 to c2. If open1 is true, the first value will be omitted. If open2 is true, the last value will be omitted. open1 and open2 default to false.
compareObs.m
contrastColor.m
cc = contrastColor( c ) Find a colour that contrasts well with C, so that if either colour is the background, the other can be used for text in the foreground. This is a fairly crude algorithm: each RGB component is 0 or 1, depending on which is further from that component of C.
copyFilesAndFolders.m
copyFilesAndFolders( oldpath, newpath, includes, excludes ) Copy all files and folders from OLDPATH to NEWPATH that match any of the patterns in INCLUDES and do not match any of the patterns in EXCLUDES. OLDPATH must exist. NEWPATH will be created. INCLUDES and EXCLUDES are cell arrays of regular expressions. If INCLUDES is empty, it matches everything.
countreps.m
y = countreps( x ) X is a vector. X is divided into runs of repeated elements. Y is set to an N*2 array in which row i = [a,b] represents the i'th run by the value A and the number of repetitions B.
cov1.m
datasize.m
n = structsize( s ) Estimate the number of bytes in anything.
datestring.m
decodePermutation.m
pairs = decodePermutation( pairs ) PAIRS is an N*(2+M) array of integers. Every integer occurs exactly twice in the first two columns, and the two occurrences are in different rows. Thus the set of pairs defines a cyclic ordering of the set of integers. PAIRS will be reordered so that the first two columns represent that cyclic ordering.
deescape.m
s = deescape( s ) Replace backslash escapes in s by the characters they stand for.
endsWithM.m
result = endsWithM( s1, s2 ) Returns 1 if the string s1 ends with the string s2, 0 otherwise. This is called endsWithM to avoid a clash with a java function present in some systems called endsWith.
eraseFileContents.m
extendHeight.m
a = extendHeight( a, extra ) Add extra zero rows to an array.
fencepostindex.m
pi = pixelindex( position, firstpost, fencelength, numposts ) Given a set of numposts fenceposts, beginning at firstpost and with total extent fencelength, compute which fencepost position is closest to.
findCurrentAxesIfAny.m
ax = findCurrentAxesIfAny() Get the current axes object, if there is one, otherwise return empty. When this returns an axes object, it is the same one that gca would return.
findjobj.m
findjobj Find java objects contained within a specified java container or Matlab GUI handle
Syntax:
[handles, levels, parentIds, listing] = findjobj(container, 'PropName',PropValue(s), ...)
Input parameters:
container - optional handle to java container uipanel or figure. If unsupplied then current figure will be used
'PropName',PropValue - optional list of property pairs (case insensitive). PropName may also be named -PropName
'position' - filter results based on those elements that contain the specified X,Y position or a java element
Note: specify a Matlab position (X,Y = pixels from bottom left corner), not a java one
'size' - filter results based on those elements that have the specified W,H (in pixels)
'class' - filter results based on those elements that contain the substring (or java class) PropValue
Note1: filtering is case insensitive and relies on regexp, so you can pass wildcards etc.
Note2: '-class' is an undocumented findobj PropName, but only works on Matlab (not java) classes
'property' - filter results based on those elements that possess the specified case-insensitive property string
Note1: passing a property value is possible if the argument following 'property' is a cell in the
format of {'propName','propValue'}. Example: FINDJOBJ(...,'property',{'Text','click me'})
Note2: partial property names (e.g. 'Tex') are accepted, as long as they're not ambiguous
'depth' - filter results based on specified depth. 0=top-level, Inf=all levels (default=Inf)
'flat' - same as specifying: 'depth',0
'not' - negates the following filter: 'not','class','c' returns all elements EXCEPT those with class 'c'
'persist' - persist figure components information, allowing much faster results for subsequent invocations
'print' - display all java elements in a hierarchical list, indented appropriately
Note1: optional PropValue of element index or handle to java container
Note2: normally this option would be placed last, after all filtering is complete. Placing this
option before some filters enables debug print-outs of interim filtering results.
Note3: output is to the Matlab command window unless the 'listing' (4th) output arg is requested
'list' - same as 'print'
'nomenu' - skip menu processing, for "lean" list of handles & much faster processing
Output parameters:
handles - list of handles to java elements
levels - list of corresponding hierarchy level of the java elements (top=0)
parentIds - list of indexes (in unfiltered handles) of the parent container of the corresponding java element
listing - results of 'print'/'list' options (empty if these options were not specified)
Note: If no output parameter is specified, then an interactive window will be displayed with a
^^^^ tree view of all container components, their properties and callbacks.
Examples:
findjobj; % display list of all javaelements of currrent figure in an interactive GUI
handles = findjobj; % get list of all java elements of current figure (inc. menus, toolbars etc.)
findjobj('print'); % list all java elements in current figure
findjobj('print',6); % list all java elements in current figure, contained within its 6th element
handles = findjobj(hButton); % hButton is a matlab button
handles = findjobj(gcf,'position',getpixelposition(hButton,1)); % same as above but also return hButton's panel
handles = findjobj(hButton,'persist'); % same as above, persist info for future reuse
handles = findjobj('class','pushbutton'); % get all pushbuttons in current figure
handles = findjobj('class','pushbutton','position',123,456); % get all pushbuttons at the specified position
handles = findjobj(gcf,'class','pushbutton','size',23,15); % get all pushbuttons with the specified size
handles = findjobj('property','Text','not','class','button'); % get all non-button elements with 'text' property
handles = findjobj('-property',{'Text','click me'}); % get all elements with 'text' property = 'click me'
Sample usage:
hButton = uicontrol('string','click me');
jButton = findjobj(hButton); % or: jButton = findjobj('property',{'Text','click me'});
jButton.setFlyOverAppearance(1);
jButton.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.HAND_CURSOR));
set(jButton,'FocusGainedCallback',@myMatlabFunction); % some 30 callback points available...
jButton.get; % list all changeable properties...
hEditbox = uicontrol('style',edit');
jEditbox = findjobj(hEditbox);
jEditbox.setCaretColor(java.awt.Color.red);
jEditbox.KeyTypedCallback = @myCallbackFunc; % many more callbacks where this came from...
jEdit.requestFocus;
Known issues/limitations:
- Cannot currently process multiple container objects - just one at a time
- Initial processing is a bit slow when the figure is laden with many UI components (so better use 'persist')
- Passing a simple container Matlab handle is currently filtered by its position+size: should find a better way to do this
- Matlab uipanels are not implemented as simple java panels, and so they can't be found using this utility
- Labels have a write-only text property in java, so they can't be found using the 'property',{'Text','string'} notation
Warning:
This code heavily relies on undocumented and unsupported Matlab functionality.
It works on Matlab 7+, but use at your own risk!
Bugs and suggestions:
Please send to Yair Altman (altmany at gmail dot com)
Change log:
2007-11-14: Fixed edge case problem with class properties tooltip; used existing object icon if available; added checkbox option to hide standard callbacks
2007-08-15: Fixed object naming relative property priorities; added sanity check for illegal container arg; enabled desktop (0) container; cleaned up warnings about special class objects
2007-08-03: Fixed minor tagging problems with a few Java sub-classes; displayed UIClassID if text/name/tag is unavailable
2007-06-15: Fixed problems finding HG components found by J. Wagberg
2007-05-22: Added 'nomenu' option for improved performance; fixed 'export handles' bug; fixed handle-finding/display bugs; "cleaner" error handling
2007-04-23: HTMLized classname tooltip; returned top-level figure Frame handle for figure container; fixed callbacks table; auto-checked newer version; fixed Matlab 7.2 compatibility issue; added HG objects tree
2007-04-19: Fixed edge case of missing figure; displayed tree hierarchy in interactive GUI if no output args; workaround for figure sub-menus invisible unless clicked
2007-04-04: Improved performance; returned full listing results in 4th output arg; enabled partial property names & property values; automatically filtered out container panels if children also returned; fixed finding sub-menu items
2007-03-20: First version posted on the MathWorks file exchange: <a href="http://www.mathworks.com/matlabcentral/fileexchange/loadFile.do?objectId=14317">http://www.mathworks.com/matlabcentral/fileexchange/loadFile.do?objectId=14317</a>
See also:
java, handle, findobj, findall, javaGetHandles
formatvalue.m
getUserDataField.m
v = getUserDataField( h, fieldname ) Get a field of the UserData attribute of the handle h. If the field is absent, [] is returned.
interp.m
v = interp( keys, vals, x ) Look up x in keys (must be in ascending order) and return corresponding value from vals, with piecewise linear interpolation.
isAncestorDirOf.m
result = isAncestorDirOf( a, d ) Return TRUE if the pathname A is a prefix of pathname D.
isFullPathname.m
is_function_handle.m
iseof.m
ie = iseof( line ) Determines whether a value read from a file is signalling the end of the file.
isminusone.m
isrootpath.m
joinfloat.m
s = join( sep, f, fmt ) Concatenate the numbers in f together, separated by sep (by default a single space). The numbers are converted to strings by the format fmt, (default %.3f).
joinstrings.m
js = joinstrings( s, ss ) ss is a cell array of strings. Concatenate all members of ss together, separated by the string s.
makeCitation.m
makeCmap.m
makeFunctionName.m
ifname = makeIFname( modelname ) Turn an arbitrary string into something that can be a valid Matlab function name or struct field name. If this is not possible, return the empty string. All runs of non-alphanumerics are replaced by underscore, and the resulting string must begin with a letter.
makeRenumbering.m
[ newToOld, oldToNew ] = makeRenumbering( boolmap ) boolmap is a bitmap indicataing which elements of a vector are to be deleted. If W == V(boolmap), then we will have W == V(newToOld) and W(oldToNew) == V except where oldToNew is zero.
makechains.m
ch = makechains( r ) R is an N*3 matrix representing a labelled relation: the row [c e1 e2] represents an arrow from e1 to e2 labelled c. The relation is assumed to be either a set of linear chains, or a single cycle. The result is a representation of the chain as a list of alternate elements and labels, in which the above instance of the relation will appear as subsequence [... e1 c e2 ...]. Where the relation consists of more than one chain, they will be separated from each other in the list by a value of 0 (which is never the value of an element or label). The result will begin with some ei and end with some c.
makefilename.m
ifname = makefilename( modelname ) Turn an arbitrary string into something that can be a valid base file name (without extension). The string is mapped to lower case, and all non-alphanumerics are replaced by underscore.
myCamlight.m
CAMLIGHT Create or set position of a light.
CAMLIGHT HEADLIGHT creates a light in the current axes at the
camera position of the current axes.
CAMLIGHT RIGHT creates a light right and up from camera.
CAMLIGHT LEFT creates a light left and up from camera.
CAMLIGHT same as CAMLIGHT RIGHT.
CAMLIGHT(AZ, EL) creates a light at AZ, EL from camera.
CAMLIGHT(..., style) set the style of the light.
Style can be 'local' (default) or 'infinite'.
CAMLIGHT(H, ...) places specified light at specified position.
H = CAMLIGHT(...) returns light handle.
CAMLIGHT creates or positions a light in the coordinate system of
the camera. For example, if both AZ and EL are zero, the light
will be placed at the camera's position. In order for a light
created with CAMLIGHT to stay in a constant position relative to
the camera, CAMLIGHT must be called whenever the camera is moved.
See also LIGHT, LIGHTANGLE, LIGHTING, MATERIAL, CAMORBIT.
mycgs.m
MYCGS Conjugate Gradients Squared Method. See CGS for the documentation. This version behaves exactly the same except that it eliminates some unnecessary code for options we never use, adds a limit on the allowed wallclock time, and prints out an indication of progress.
myiterapp.m
MYITERAPP Multiply afun and x.
mylsqr.m
LSQR LSQR Method.
X = LSQR(A,B) attempts to solve the system of linear equations A*X=B
for X if A is consistent, otherwise it attempts to solve the least
squares solution X that minimizes norm(B-A*X). The N-by-P coefficient
matrix A need not be square but the right hand side column vector B
must have length N.
X = LSQR(AFUN,B) accepts a function handle AFUN instead of the matrix A.
AFUN(X,'notransp') accepts a vector input X and returns the
matrix-vector product A*X while AFUN(X,'transp') returns A'*X. In all
of the following syntaxes, you can replace A by AFUN.
X = LSQR(A,B,TOL) specifies the tolerance of the method. If TOL is []
then LSQR uses the default, 1e-6.
X = LSQR(A,B,TOL,MAXIT) specifies the maximum number of iterations. If
MAXIT is [] then LSQR uses the default, min([N,P,20]).
X = LSQR(A,B,TOL,MAXIT,M) and LSQR(A,B,TOL,MAXIT,M1,M2) use P-by-P
preconditioner M or M = M1*M2 and effectively solve the system
A*inv(M)*Y = B for Y, where Y = M*X. If M is [] then a preconditioner
is not applied. M may be a function handle MFUN such that
MFUN(X,'notransp') returns M\X and MFUN(X,'transp') returns M'\X.
X = LSQR(A,B,TOL,MAXIT,M1,M2,X0) specifies the P-by-1 initial guess. If
X0 is [] then LSQR uses the default, an all zero vector.
[X,FLAG] = LSQR(A,B,...) also returns a convergence FLAG:
0 LSQR converged to the desired tolerance TOL within MAXIT iterations.
1 LSQR iterated MAXIT times but did not converge.
2 preconditioner M was ill-conditioned.
3 LSQR stagnated (two consecutive iterates were the same).
4 one of the scalar quantities calculated during LSQR became too
small or too large to continue computing.
[X,FLAG,RELRES] = LSQR(A,B,...) also returns estimates of the relative
residual NORM(B-A*X)/NORM(B). If RELRES <= TOL, then X is a
consistent solution to A*X=B. If FLAG is 0 but RELRES > TOL, then X is
the least squares solution which minimizes norm(B-A*X).
[X,FLAG,RELRES,ITER] = LSQR(A,B,...) also returns the iteration number
at which X was computed: 0 <= ITER <= MAXIT.
[X,FLAG,RELRES,ITER,RESVEC] = LSQR(A,B,...) also returns a vector of
estimates of the residual norm at each iteration including NORM(B-A*X0).
[X,FLAG,RELRES,ITER,RESVEC,LSVEC] = LSQR(A,B,...) also returns a vector
of least squares estimates at each iteration:
NORM((A*inv(M))'*(B-A*X))/NORM(A*inv(M),'fro'). Note the estimate of
NORM(A*inv(M),'fro') changes, and hopefully improves, at each iteration.
Example:
n = 100; on = ones(n,1); A = spdiags([-2*on 4*on -on],-1:1,n,n);
b = sum(A,2); tol = 1e-8; maxit = 15;
M1 = spdiags([on/(-2) on],-1:0,n,n);
M2 = spdiags([4*on -on],0:1,n,n);
x = lsqr(A,b,tol,maxit,M1,M2);
Or, use this matrix-vector product function
%-----------------------------------%
function y = afun(x,n,transp_flag)
if strcmp(transp_flag,'transp')
y = 4 * x;
y(1:n-1) = y(1:n-1) - 2 * x(2:n);
y(2:n) = y(2:n) - x(1:n-1);
elseif strcmp(transp_flag,'notransp')
y = 4 * x;
y(2:n) = y(2:n) - 2 * x(1:n-1);
y(1:n-1) = y(1:n-1) - x(2:n);
end
%-----------------------------------%
as input to LSQR:
x1 = lsqr(@(x,tflag)afun(x,n,tflag),b,tol,maxit,M1,M2);
Class support for inputs A,B,M1,M2,X0 and the output of AFUN:
float: double
See also BICG, BICGSTAB, CGS, GMRES, MINRES, PCG, QMR, SYMMLQ, LUINC,
FUNCTION_HANDLE.
namedColor.m
namedHue.m
newfilename.m
f = newfilename( filename ) Given a filename, find a filename similar to it for which a file does not already exist, by inserting a 4-digit number before the extension, starting from 0001 and counting upwards as far as necessary.
nextPresent.m
i = nextPresent( i, retained ) RETAINED is a list of booleans. I is an index into that list. If RETAINED(I) is true, I is returned. Otherwise, the index of the first element of RETAINED after I is returned, if any. Otherwise, the index of the last element of RETAINED before I is returned, if any. Otherwise, 0 is returned.
notminusone.m
num2string.m
s = num2string( n ) Convert the number n to a string without unnecessary zeroes or decimal points. decpl (default 6) is the maximum number of decimal places to allow.
othersOf3.m
bc = othersOf3( a ) [b,c] = othersOf3( a ) If a is in the range 1..3, set bc or [b,c] to the successors of a.
parseNumList.m
partitionlist.m
s = partitionlist( n )
Set s{i} equal to find(n==j), where j is the i'th smallest value
occurring in n.
plot3circle.m
plot3circle( centre, numpts, v1, v2, varargin ) Plot a circle in 3d with the given centre, radii v1 and v2, and numpts points. The remaining arguments are passed to plot3. centre, v1, and v2 can all be k*3 matrices, to plot k circles at once.
plotProfile.m
plotProfile( data ) DATA is an N*P matrix of N rows of P values. Plot each row of values against index, successively.
plotconic.m
h = plotconic( ax, x, r, steps ) Plot a lathed surface or generalised cone. AX is the axes object into which to plot. Z and R are vectors of equal length. STEPS is an integer. The surface is plotted, circularly symmetric about the z axis, for which the radius at each point of Z is R. STEPS is the number of steps to take around the z axis in sweeping out the surface. The remaining arguments are passed to SURF. The surface will be coloured according to the z coordinate. See also: SURF.
plotobj.m
plotvecs.m
plotvecs( v, ... ) Plot a set of line segments. V1 and V2 are both N*2 or N*3 matrices. Plot a line from each member of V1 to the corresponding member of V2. Pass all remaining arguments to plot3.
printstrings.m
quiverpts.m
readWholeFile.m
readfile.m
readtextfile.m
reformatText.m
s = reformatText( s ) Wherever s contains a single newline not followed by a space, replace it by a space. Leave all other newlines alone.
renumberArray.m
v1 = renumberArray( v, ren ) Replace every element x of v by ren(x). Works for arrays of any number of dimensions.
repeatString.m
replaceval.m
a = replaceend( a, oldval, newval ) Replace every occurrence of OLDVAL in A by NEWVAL.
rescaleimage.m
imagedata = rescaleimage( imagedata, xwidth, ywidth ) Resample an image to a lower resolution. imagedata should be an X*Y*3 array of uint8. This is rather inefficient when xwidth and ywidth are large, and is intended for making small thumbnails of no more than 64 pixels square. xwidth and ywidth must not be larger than the corresponding dimension of imagedata.
samesize.m
same = samesize( a, b ) Determine whether sizes A and B are the same.
saturate.m
c1 = saturate( v, c ) c is an RGB colour. v is a vector of N reals. The results is an N*3 array of N colours, being copies of c saturated by each element of v. Where v is 0, the colour is [1,1,1] (white), and where v is 1, the colour is c, with linear interpolation between. There is no check that v or c are within the range 0..1
scaleticks.m
[ticks,ranks] = scaleticks( lo, hi ) Given a scale ranging from lo to hi, choose suitable values to put tick marks against. 0, if within the range and not too close to a nonzero endpoint, always gets a tick. We scale the range so that the end with larger magnitude has nagnitude between 1 and 10. Then we choose ticks at all the integer points in the range, or more finely if that doesn't give enough ticks. Finally, we force the endpoints to receive ticks. ranks specifies which of the ticks are major and which minor -- for example, in order to draw the major ones thicker than the minor ones. 0 is always a major rank. Currently, it is the only major rank. The higher the rank, the more important the tick mark. The number is actually the line thickness in pixels.
segmentBetween.m
b = segmentBetween( a, i1, i2 ) Return the segment of the 1-dimensional array A that lies between index i1 and i2, including i1 but not i2. If i2 is less than i1 then the segment should proceed from i1 to the end of A and continue from the beginning. If i2==i1, the result is empty. i1 and i2 are reduced mod length(a) to lie within the bounds of A.
segmentOfCircularList.m
[indexes,values] = segmentOfCircularList( cl, v1, v2 ) cl is a circular array in which both v1 and v2 occur once. Find the segment of cl strictly between v1 and v2. If v1 is empty and v2 is present, the list from the start up to bevore v2 is returned. If v1 is present and v2 is empty, the list from after v1 to the end is returned. If both are empty, the whole list is returned.
setCamlight.m
setCamlight( theaxes, az, el, force ) Set the position of a light relative to the camera in terms of azimuth and elevation. The values of az and el will be stored in the UserData of theaxes, and these values will be used as defaults. The on argument can be either true, false, or empty. The default is empty. If true, a light will be created if none exists. If false, any light will be deleted and none will be created. If empty (the default), a light will be created only if none exists.
shortestSegmentBetween.m
b = segmentBetween( n, i1, i2 ) Return the segment of 1:n that lies between index i1 and i2, including i1 but not i2. The segment will proceed downwards or upwards, whichever gives the shortest result, and going round the end of the array if necessary. If i2==i1, the result is empty. i1 and i2 are reduced mod n to lie within the bounds of 1:n.
showhideAxisContents.m
spacing.m
spacing( f, n ) Print n spaces to file id f.
split.m
toks = split( pat, str ) Implementation of the Perl split() function. Splits the string STR wherever the pattern PAT matches, and returns a cell array of the strings between the matches. If the string begins or ends with a match, the cell array will correspondingly begin or end with an empty string.
splitintolines.m
splitpathname.m
[parentname,filename] = splitpathname( pathname ) Split a path name into the parent and base parts. Unlike fileparts(), this does not split off the file extension, if any. The file version, which was returned as the fourth result of fileparts in versions of Matlab prior to 2012, is ignored. See also: fileparts.
spreadHue.m
h = spreadHue( h, alph ) This takes a value of hue in the range 0..1 and attempts to map it to actual hue in a manner that better matches psychological distance, by spreading apart the green/blue part of the colour wheel. ALPH is a parameter specifying the amount of spreading out. 0.2 is about right.
step.m
s = step( r1, r2, n, open1, open2 ) Construct a row vector of equally spaced values from r1 to r2, containing n intervals. If open1 is true, the first value will be omitted. If open2 is true, the last value will be omitted. open1 and open2 default to false.
Overloaded methods:
system/step
DynamicSystem/step
stitchints.m
string2num.m
subtractiveMix.m
c = subtractiveMix( a, s ) s is a parameter between 0 and 1. a is an N*M*3 array
tokeniseString.m
tokens = tokeniseString( s ) Convert s into a cell array of tokens, splitting it at white space.
trimimageborders.m
trimnumber.m
x = trimnumber( lo, x, hi ) Force every element of x to lie within lo..hi. x may be a numerical array of any size and shape.
trymkdir.m
ok = trymkdir( dirname )
Creates a directory and returns a boolean to indicate success or failure.
If it fails, a warning will be printed.
See also:
MKDIR
trymkdircd.m
ok = trymkdircd( targetdir ) Create the directory TARGETDIR if it does not exist, then cd to it. On success, olddir will be set to the previous current directory. On failure for any reason, olddir will be set to the empty string.
twonums2str.m
uint8color.m
unspace.m
s = unspace( s ) Remove the spaces from the string or cell array of strings s.
updateBoolList.m
useAllProcessors.m
useAllProcessors( msg ) Attempt to make use of all available processors. This code is Windows-specific and invokes deprecated Matlab procedures, and should probably not be used. It will not actually throw an error though.
userHomeDirectory.m
vecsums.m
vs = vecsums( v ) Set vs(i) to the sum of v(1:i) for all i.
warningDialog.m
warningDialog( format, varargin ) Put up a one-button dialog to warn the user of something. The text of the dialog will be the result of sprintf( format, varargin ).
wordsplit.m
toks = wordsplit( str, spacing, delimiters ) The string STR is split into tokens. Any sequence of one or more whitespace characters is deleted and replaced by a token break. DELIMITERS is a string or a cell array of strings: every occurrence in STR of any of these strings is taken to be a token. The result is a cell array of strings.
writefile.m
ok = writefile( filename, contents ) Write a string to a named file. Returns true on success, false on failure.
bulgeProfile.m
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\cmdinterp
addCommandToGUIElement.m
addCommandToGUIElement( h, cmd, requiresMesh, args ) Add the CMD, REQUIRESMESH flag, and cellarray ARGS to the UserData element of the GUI component H.
argToMatlabString.m
argToScriptString.m
atend.m
[tokenstream,ended] = atend( tokenstream ) Test whether a token stream is at the end.
attemptCommand.m
attemptCommand( h, i, cmd, varargin )
If there is no current mesh, do nothing.
If there is a mesh and the simulation is not running, execute the specified
command CMD(VARARGIN{:}). If REPLOT is true, redraw the mesh.
If the simulation is running, and NEEDSSTOP is false, add the command to
the command queue. If NEEDSSTOP is true, ask for confirmation, and
if given, also set the stop flag.
attemptNewMeshCommand.m
m = attemptNewMeshCommand( h, replace cmd, varargin )
Assumes the simulation is not running. Executes the specified command
cmd(varargin{:}), which creates a new mesh. If the GUI specifies that
a random perturbation should be made, it does so. If REPLACE is true,
the old mesh is discarded, otherwise as many properties as possible of
the old mesh are copied to the new one.
If successful, it installs the new mesh into h.
buildRSSSdialog.m
buildRSSSdialog( fn ) Create a dialog from the dialogspec contained in the file called fn. The result is a handle to the figure it creates, or -1 if it could not be created.
checkType.m
ok = checkType( msg, type, arg ) Check the type of arg and print an error message if it is not of the required type.
checkcommandargs.m
ok = checkcommandargs( commandname, s, mode, varargin ) varargin is a series of string arguments. s is a struct. If mode is 'incl', determine whether the fields of s include all the members of varargin. If mode is 'only', determine whether the fields of s are contained in varargin. If mode is 'exact', determine whether the fields of s are precisely the members of varargin. For modes 'only' and 'exact', if s is found to have extra fields then these fields will be deleted from s.
closetokenlinestream.m
tokenstream = closetokenlinestream( tokenstream ) Close the token-line stream and the underlying file, discarding any unused data.
closetokenstream.m
tokenstream = closetokenstream( tokenstream ) Close the token stream and the underlying file, discarding any unused data.
concattokenstreams.m
ts2 = concattokenstreams( ts0, ts1 ) Create a token stream that reads first from ts0, and when that ends, from ts1.
docommands.m
m = docommands( m, filename, varargin )
Execute Matlab commands from the file. The optional arguments can
request the leaf to be plotted after each leaf command, and for
execution to be paused after each leaf command. Each command is echoed
to the terminal window before it is executed.
Leaf commands are defined to be Matlab statements of the form
m = leaf_xxxxxx( ... );
where leaf_xxxxxx is a command for creating or modifying a leaf.
Note that the left hand side of the assignment must be the variable m.
The result of docommands is the result of the final leaf command.
Every command in the Matlab file must be on a single line. This
includes compound commands such as for-loops: the entire for...end must
be on a single line.
Options:
'plot': draw the leaf after every command (except for leaf_plot
commands, which draw the leaf themselves).
'pause': pause Matlab after each command. 'pause' implies 'plot'.
'nostop': Don't try to execute the file line by line, just eval the
entire contents at once.
docommandsText.m
m = docommandsText( m, cmdtext, varargin )
Execute Matlab commands from the cell array of strings. The optional
arguments can request the leaf to be plotted after each leaf command, and
for execution to be paused after each leaf command. Each command is echoed
to the terminal window before it is executed.
Leaf commands are defined to be Matlab statements of the form
m = leaf_xxxxxx( ... );
where leaf_xxxxxx is a command for creating or modifying a leaf.
Note that the left hand side of the assignment must be the variable m.
The result of docommands is the result of the final leaf command.
Every command in the Matlab file must be on a single line. This
includes compound commands such as for-loops: the entire for...end must
be on a single line.
Options:
'plot': draw the leaf after every command (except for leaf_plot
commands, which draw the leaf themselves).
'pause': pause Matlab after each command. 'pause' implies 'plot'.
emptytokenstream.m
execcmds.m
v = execcmds( filename, syntaxdef, v ) Apply commands from the given file, with meanings defined by syntaxdef, to the structure v.
execcmdstring.m
v = execcmdstring( s, syntaxdef, v, do ) Apply the commands contained in the string s, with meanings defined by syntaxdef, to the structure v.
executeCommands.m
m = executeCommands( m, c, ploteach, h ) M is a mesh. C is a list of commands to execute. C is an array of structures with fields 'cmd' and 'args', being respectively the name of a script command and a cell array of its arguments. H, if given, is the handle structure of the GUI.
getTypedArg.m
isDotName.m
isMatlabName.m
isType.m
ok = isType( x, type ) Determine whether X has type TYPE. TYPE can be a string or a cell array of strings. In the latter case, the result is true if X has a type contained in the cell array.
makescriptcommandtext.m
opentokenlinestream.m
tokenstream = opentokenlinestream( filename ) Create a token-line input stream from a filename. Each read from this returns a cell array of tokens, consisting of the contents of a nonempty line.
opentokenstream.m
Create a token input stream from a filename.
peektoken.m
putback.m
tokenstream = putback( tokenstream, token ) Put a token back into the stream, so that that token will be the next token read. Note that the token is not inserted into the underlying file.
readNumbers.m
[ts,argarray] = readNumbers( ts ) Read numbers from the token stream ts until end of stream or a non-number is detected. Return the numbers in the one-dimensional array argarray.
readsyntax.m
syntaxdef = readsyntax( filename ) Reads a command syntax definition from the given file.
readtoken.m
[tokenstream,token] = readtoken( tokenstream ) Read a token from a stream. At end of stream, the empty string will be returned and the underlying file will be closed.
readtokenline.m
[ts,toks] = readtokens( ts ) Read a nonempty line of tokens. Returns an empty cell array at end of file.
recordcommand.m
refillbuffer.m
tokenstream = refillbuffer( tokenstream ) Read a line from the input file and tokenise it. Repeat until at least one token is found or the end of file is reached.
safemakestruct.m
s = safemakestruct( self, args ) Construct a struct S from the cell array ARGS by S = STRUCT(ARGS), but catch and report errors. ARGS is expected to be the VARARGIN argument of the function this is called from. ARGS may also be a structure, in which case S is set to ARGS and OK to true. If ARGS is absent, S is set to the empty structure and OK to true. Unlike STRUCT, SAFEMAKESTRUCT does not treat cell array arguments specially. The SELF argument is a string used in error messages, and should be the name of the procedure this function was called from (e.g. as provided by MFILENAME()). If SELF is empty, no error messages will be printed.
scriptcommand.m
m = scriptcommand( m, commandname, varargin ) Execute the command with the given name. The arguments are varargin.
showRSSS.m
showRSSS( fid, s, indent ) Write to the console a pretty-printed form of the dialog description s. The indent defaults to 0.
stringtokenstream.m
Create a token input stream from a string or a cell array of strings.
testtok.m
tscmds.m
v = tscmds( ts, syntaxdef, v ) Apply commands from the given token stream, with meanings defined by syntaxdef, to the structure v.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\docs
gendoc.m
gogt.m
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\growth
BSequilibrate.m
[nodes,abserr, relerr, stretchchange,numiters,ok] = BSequilibrate( ...
nodes, edgeends, restlengths, springconst, t, iters, maxerr, finald, ...
fig, progressCallback )
Use the ball and spring method to equilibrate a mesh.
ClusterControl.m
function ClusterControl(arg,opt,projectnamecell)
Use GUI that allows one to setup growth projects on the cluster
Run them
Retrieve the results and clear up by deleting the intermediate files
CONFIGURATION for running projects that are not the snapdragon
Find the line calling VMSReport and change as illustrated below.
Usage
1) At the beginning of the session, start ClusterControl and press the
svn update button - this ensures that the DArT_Toolshed on the cluster is
up to date. (To install the DArT_Toolshed in the firstplace, use WinSCP.
2) use SilentGFtbox to prepare an experiment, e.g.
SilentGFtbox('Name','NewFig4test2','dt',1,'Stages',[2,5,7],'Use','Cluster')
Having set up the experiment(s) this program will send the project and the
commands required to run it (them) on the cluster.
Finally, it will keep a note of the program that will
get the results back from the cluster.
Not only does ClusterControl keep a list of experiments, but it also
has buttons to enable you to check the processing queue, your directories
on the cluster.
To forcibly stop the automatic collection of results type
ti=timerfind; % finds all the timers
stop(ti); % this stops all the timers
delete(ti); % and deletes them all
J.Andrew Bangham, 2008
global ClusterControl_fig
ClusterControlAdd.m
global ClusterControl_fig
ClusterControlAddGrace.m
global ClusterControl_fig
ClusterControlPOP.m
global ClusterControl_fig
ClusterDELEXP.m
ClusterDELEXPGrace.m
ClusterDELJOB.m
ClusterDELJOBGrace.m
ClusterDELPROJ.m
ClusterDELPROJGrace.m
ClusterDELSH.m
ClusterDIR.m
ClusterDIRV2.m
ClusterMonitor.m
function ClusterMonitor(arg,opt,projectnamecell)
Use GUI that allows one to setup growth projects on the cluster
Run them
Retrieve the results and clear up by deleting the intermediate files
CONFIGURATION for running projects that are not the snapdragon
Find the line calling VMSReport and change as illustrated below.
Usage
1) At the beginning of the session, start ClusterMonitor and press the
svn update button - this ensures that the DArT_Toolshed on the cluster is
up to date. (To install the DArT_Toolshed in the firstplace, use WinSCP.
2) use SilentGFtbox to prepare an experiment, e.g.
SilentGFtbox('Name','NewFig4test2','dt',1,'Stages',[2,5,7],'Use','Cluster')
Having set up the experiment(s) this program will send the project and the
commands required to run it (them) on the cluster.
Finally, it will keep a note of the program that will
get the results back from the cluster.
Not only does ClusterMonitor keep a list of experiments, but it also
has buttons to enable you to check the processing queue, your directories
on the cluster.
To forcibly stop the automatic collection of results type
ti=timerfind; % finds all the timers
stop(ti); % this stops all the timers
delete(ti); % and deletes them all
J.Andrew Bangham, 2008
global ClusterMonitor_fig
ClusterMonitorGrace.m
function ClusterMonitorGrace(arg,opt,projectnamecell)
Use GUI that allows one to setup growth projects on the cluster
Run them
Retrieve the results and clear up by deleting the intermediate files
CONFIGURATION for running projects that are not the snapdragon
Find the line calling VMSReport and change as illustrated below.
Usage
1) At the beginning of the session, start ClusterMonitorGrace and press the
svn update button - this ensures that the DArT_Toolshed on the cluster is
up to date. (To install the DArT_Toolshed in the firstplace, use WinSCP.
2) use SilentGFtbox to prepare an experiment, e.g.
SilentGFtbox('Name','NewFig4test2','dt',1,'Stages',[2,5,7],'Use','Cluster')
Having set up the experiment(s) this program will send the project and the
commands required to run it (them) on the cluster.
Finally, it will keep a note of the program that will
get the results back from the cluster.
Not only does ClusterMonitorGrace keep a list of experiments, but it also
has buttons to enable you to check the processing queue, your directories
on the cluster.
To forcibly stop the automatic collection of results type
ti=timerfind; % finds all the timers
stop(ti); % this stops all the timers
delete(ti); % and deletes them all
J.Andrew Bangham, 2008
global ClusterMonitorGrace_fig
ClusterQSTAT.m
ClusterQSTATGrace.m
ClusterRun.m
function GFtboxCommandG(ProjectName,Args.Directory,Args.number_steps,Args.stepsize)
A Matlab program for running models on a cluster
Based on GFtboxCommand
Arguments are given in pairs, ['arg',value]. To see a list of args type ClusterRun('Args');
For running growth models in batch mode. Results are filed in a
subdirectory
ProjectName:Movies:experimentname:meshes stores full mesh .mat files
At the end of each stage/step the mesh is stored in a separate file.
In addition, the command line used to invoke GFtboxCommand
and a copy of the interaction function are saved in the experimentname directory.
The meshes can be viewed using VMS (View Mesh System)
or VMSReport. They can also be moved into the project directory where
GFtbox will recognise them as 'Stages'.
When running jobs on the cluster, GFtboxCommand will automatically
log the fact with a program called ClusterControl.
To run on the cluster you must have
1) Your (UEA) Cluster username
2) Your (UEA) Cluster username Password
3) The (UEA) Cluster name, e.g. eslogin.uea.ac.uk
4) Path to your filespace within the cluster (excluding your
name)
(e.g 'gpfs/tmpscratch01/sys/')
(or 'gpfs/sys/')
and the following programs installed on your computer
4) WinSCP
5) Putty
6) pscp
7) plink
these can be installed on a Mac from the Terminal using MacPorts (e.g. sudo port install putty)
There is an option to output a set of shell scripts (.sh files) that
enable the results to be computed on a cluster in parallel.
This is invoked by the 'Use','Cluster', command pair.
Usage, all argument pairs are optional
GFtboxCommand(...
'State','RunNow',... % status of command, options are:
% default is 'RunNow', i.e. when 'State' is not used then
% system is run on the current computer
%
% The following only apply to running on the cluster
% 'Run' create and run a single command
%
% 'Begin' to begin assembling a batch of commands
% 'Add' to add to the existing batch
% 'Start' to add to and then run batch of commands
%
'Use','Cluster' % use the cluster if it is accessible
% default is not to use the cluster
'Name','IMotif2a',... % project to be run
'Path', pwd,... % present working directory
either specify the modelling time in steps or Args.stages
'Args.dt',[0.1, 0.01,...] % default value is set by the project itself
% this command is used to change Args.dt
Using time
'Stages',[80,120,...] % default, output at every iteration
% list of Args.stages (in hours) that are to be
% output.
% Overrides Stepsize.
% Overrides Args.total_time, i.e. Args.total_time=max(Args.stages)
% stage filenumbers are time - consistent
% GFtbox
'Total_time',tvalue,...% i.e. Args.number_steps = tvalue/Args.dt, also see Stages
Using steps
'N_steps', 20,... % number of steps to be run
'Stepsize',1,... % interval between steps that are recorded
% overridden by Stages
% defaut 1
'Flatten',true or false,...% The mesh will be dissected, (edges to be dissected must
% be entered into the mesh using the GUI).
% The mesh will then be dissected,exploded and Args.flattened.
% after the last step (or stage).
% it can take a long time.
'Mut_list',{'cych','div'},...% cell array of morphogen names to be set
% to zero activity
% default is 'wilArgs.dtype' i.e. all morph_a=1
'param',[indices] % it is possible to automatically
%create set of experiments that systematically vary parameters
%of the model. These have to be setup inside the interaction
%function. e.g. the parameter called 'param' is set up with
%m.userdata.ranges.param.range=[0, 1.2, 5, 10]
%m.userdata.ranges.param.index=3; % this sets the default, i.e.
%param=5. By setting an invalid index using
%on the GFtboxCommand command line, i.e. 10
in this case, each value of the parameter
will be used. If two range parameters are
set then the combinations will be run as
separate jobs, i.e. if there were 4 and 5
alternatives respectively, 20 experiments
would be created.
%Sensitivity testing
%m.userdata.ranges.sensitivity.range
%m.userdata.ranges.sensitivity.index
this is a reserved userdatat ranges field
that is recognised by GFtboxCommand. In
To perform a sensitivity test, there must
be set of obj files in a directory called
objs. One obj per time step.
It is differences between the test sensitivity values
and these obj files that will be computed.
that will
'Subdiv',false, % default, false,
% true then FE model will be subdivided
% to four times the number of vertices at the beginning
%
'ExpID',name, % not for general use. Used internally by GFtboxCommand
% to label experiments as they are run on
% the cluster
e.g.
Run on personal computer
GFtboxCommand('Name','HoleMotif4','Stages',[5,15,25]);
Run on cluster, exploring two range parameters
GFtboxCommand('Name','HoleMotif4','Stages',[5,15,25],'wound_production',3,'growth',1,'Use','Cluster');
Run on cluster, exploring the effect of different Args.dt and number of
vertices
ClusterRun('State','Start','Name','GPT_SnapPol_20111108','Stages',[250 335 340 370 410 490 570],'Use','Cluster','modelnumber',[1 2],'mingradient',[1 2]);
GFtboxCommand('State','Begin','Name','NewFig4','Args.dt',1.0,'Stages',[2,5,7],'Use','Cluster');
GFtboxCommand('State','Add','Name','NewFig4','Args.dt',0.1,'Stages',[2,5,7],'Use','Cluster');
GFtboxCommand('State','Add','Name','NewFig4','Args.dt',1.0,'Subdiv',true,Stages',[2,5,7],'Use','Cluster');
GFtboxCommand('State','Start','Name','NewFig4','Args.dt',0.1,'Subdiv',true,'Stages',[2,5,7],'Use','Cluster');
Try a range of Args.dts, run for two separate models, for all combinations
of the specified mutations
GFtboxCommand('State','Start','Name','NewFig4','Args.dt',[0.1 0.5 1] ,'Subdiv',true,'Stages',[2,5,7],'Use','Cluster','modelname',[1 2],'Mut_List',{'mutation1','mutation1'});
J.Andrew Bangham, 2008
Jacob Newman, 2011
if isunix
% then assume it is running on the cluster and the paths are to be
% setup relative to the current directory
pathnames=fullfile(pwd,'DArT_Toolshed');
addpath(genpath(pathnames));
end
ClusterSVN.m
CopyAndRun.m
FindMorphogenIndex.m
FindMorphogenName.m
Convert any set of morphogens to names. mgen can be any of: a single morphogen index an array of morphogen indexes a string a cell array of strings. The result is always a cell array of strings. Morphogen indexes that are out of range are ignored. Morphogen names are checked for validity, and invalid ones ignored.
GFTwindow_KeyPressFcn.m
GFTwindow_KeyPressFcn(hObject,eventdata) Process keystroke events.
GFtboxAlert.m
GFtboxCloseRequestFcn.m
GFtboxCommand.m
function GFtboxCommand(ProjectName,Directory,number_steps,stepsize)
For running growth models in batch mode. Results are filed in a
subdirectory
ProjectName:Movies:experimentname:meshes stores full mesh .mat files
At the end of each stage/step the mesh is stored in a separate file.
In addition, the command line used to invoke GFtboxCommand
and a copy of the interaction function are saved in the experimentname directory.
The meshes can be viewed using VMS (View Mesh System)
or VMSReport. They can also be moved into the project directory where
GFtbox will recognise them as 'Stages'.
When running jobs on the cluster, GFtboxCommand will automatically
log the fact with a program called ClusterControl.
To run on the cluster you must have
1) Your (UEA) Cluster username
2) Your (UEA) Cluster username Password
3) The (UEA) Cluster name, e.g. eslogin.uea.ac.uk
4) Path to your filespace within the cluster (excluding your
name)
(e.g 'gpfs/tmpscratch01/sys/')
(or 'gpfs/sys/')
and the following programs installed on your computer
4) WinSCP
5) Putty
6) pscp
7) plink
these can be installed on a Mac from the Terminal using MacPorts (e.g. sudo port install putty)
There is an option to output a set of shell scripts (.sh files) that
enable the results to be computed on a cluster in parallel.
This is invoked by the 'Use','Cluster', command pair.
Usage, all argument pairs are optional
GFtboxCommand(...
'State','RunNow',... % status of command, options are:
% default is 'RunNow', i.e. when 'State' is not used then
% system is run on the current computer
%
% The following only apply to running on the cluster
% 'Run' create and run a single command
%
% 'Begin' to begin assembling a batch of commands
% 'Add' to add to the existing batch
% 'Start' to add to and then run batch of commands
%
'Use','Cluster' % use the cluster if it is accessible
% default is not to use the cluster
'Name','IMotif2a',... % project to be run
'Path', pwd,... % present working directory
either specify the modelling time in steps or stages
'dt',[0.1, 0.01,...] % default value is set by the project itself
% this command is used to change dt
Using time
'Stages',[80,120,...] % default, output at every iteration
% list of stages (in hours) that are to be
% output.
% Overrides Stepsize.
% Overrides total_time, i.e. total_time=max(stages)
% stage filenumbers are time - consistent
% GFtbox
'Total_time',tvalue,...% i.e. number_steps = tvalue/dt, also see Stages
Using steps
'N_steps', 20,... % number of steps to be run
'Stepsize',1,... % interval between steps that are recorded
% overridden by Stages
% defaut 1
'Flatten',true or false,...% The mesh will be dissected, (edges to be dissected must
% be entered into the mesh using the GUI).
% The mesh will then be dissected,exploded and flattened.
% after the last step (or stage).
% it can take a long time.
'Mut_list',{'cych','div'},...% cell array of morphogen names to be set
% to zero activity
% default is 'wildtype' i.e. all morph_a=1
'param',[indices] % it is possible to automatically
%create set of experiments that systematically vary parameters
%of the model. These have to be setup inside the interaction
%function. e.g. the parameter called 'param' is set up with
%m.userdata.ranges.param.range=[0, 1.2, 5, 10]
%m.userdata.ranges.param.index=3; % this sets the default, i.e.
%param=5. By setting an invalid index using
%on the GFtboxCommand command line, i.e. 10
in this case, each value of the parameter
will be used. If two range parameters are
set then the combinations will be run as
separate jobs, i.e. if there were 4 and 5
alternatives respectively, 20 experiments
would be created.
%Sensitivity testing
%m.userdata.ranges.sensitivity.range
%m.userdata.ranges.sensitivity.index
this is a reserved userdatat ranges field
that is recognised by GFtboxCommand. In
To perform a sensitivity test, there must
be set of obj files in a directory called
objs. One obj per time step.
It is differences between the test sensitivity values
and these obj files that will be computed.
that will
'Subdiv',false, % default, false,
% true then FE model will be subdivided
% to four times the number of vertices at the beginning
%
'ExpID',name, % not for general use. Used internally by GFtboxCommand
% to label experiments as they are run on
% the cluster
e.g.
Run on own computer, exploring one range parameters
GFtboxCommand('Path','C:\Users\AB\GFtbox_Projects\Motifs','Name','GPT_CASES_NOPQ','Stages',[10,20]);
GFtboxCommand('Path','C:\Users\AB\GFtbox_Projects\Motifs','Name','GPT_CASES_NOPQ','Stages',[10,20],'modelname',[1,3]);
Run on cluster, exploring one range parameters
GFtboxCommand('Path','C:\Users\AB\GFtbox_Projects\Motifs',...
'Name','GPT_CASES_NOPQ','Stages',[10,20]),'Use','Cluster');
GFtboxCommand('Path','C:\Users\AB\GFtbox_Projects\Motifs',...
'Name','GPT_CASES_NOPQ','Stages',[10,20],'modelname',[1,3],'Use','Cluster');
Run on cluster, exploring the effect of different dt and number of
vertices
GFtboxCommand('State','Begin','Name','NewFig4','dt',1.0,'Stages',[2,5,7],'Use','Cluster');
GFtboxCommand('State','Add','Name','NewFig4','dt',0.1,'Stages',[2,5,7],'Use','Cluster');
GFtboxCommand('State','Add','Name','NewFig4','dt',1.0,'Subdiv',true,Stages',[2,5,7],'Use','Cluster');
GFtboxCommand('State','Start','Name','NewFig4','dt',0.1,'Subdiv',true,'Stages',[2,5,7],'Use','Cluster');
Try a range of dts, run for two separate models, for all combinations
of the specified mutations
GFtboxCommand('State','Start','Name','NewFig4','dt',[0.1 0.5 1] ,'Subdiv',true,'Stages',[2,5,7],'Use','Cluster','modelname',[1 2],'Mut_List',{'mutation1','mutation1'});
J.Andrew Bangham, 2008
Jacob Newman, 2011
if isunix
% then assume it is running on the cluster and the paths are to be
% setup relative to the current directory
pathnames=fullfile(pwd,'DArT_Toolshed');
addpath(genpath(pathnames));
end
GFtboxDir.m
dirname = GFtboxDir() Find the Growth Toolbox directory.
GFtboxDirectory.m
GFtboxPath.m
GFtboxRevision.m
[rev,date] = GFtboxRevision() Determine the revision number and date of the GFtbox code. Do this from the SVN admin data if present, otherwise from GFtbox_version.txt.
GFtboxUpdateFonts.m
GUIPlotMesh.m
This must not be called while the simulation is running.
GaussQuadPoints.m
gqp = GaussQuadPoints() Calculate the Gaussian quadrature points
for a triangular prism. The result is a 3*6 matrix.
GetTransform6.m
function MV = GetTransform6( M ) Given a 3*3 linear transformation M, calculate the 6*6 matrix MV which is appropriate for transforming symmetric second rank tensors represented as 6-element vectors.
IsotropicComplianceMatrix.m
C = IsotropicComplianceMatrix( K, nu ) Compute the 6*6 compliance matrix for an isotropic material with bulk modulus K and Poisson's ratio nu. WARNING: I don't believe this is accurate. This procedure is never used.
IsotropicStiffnessMatrix.m
D = IsotropicStiffnessMatrix( K, nu, nuNormal ) Compute the 6*6 stiffness matrix for an isotropic material with bulk modulus K and Poisson's ratio nu. If K, nu, and nuNormal are vectors of the same length N > 1, D is returned as an 6*6*N matrix. nuNormal defaults to nu (and in fact is not used anyway).
IsotropicStiffnessMatrixGnu.m
D = IsotropicStiffnessMatrixGnu(( G, nu ) Compute the 6*6 stiffness matrix for an isotropic material with shear modulus G and Poisson's ratio nu, multiplied by 1-2*nu. If G and nu are vectors of the same length N > 1, D is returned as an 6*6*N matrix.
Kgauss.m
[k,f] = Kgauss( v, gauss, C, eps0 )
Calculate the K matrix and force vector for a finite element cell.
v: cell vertexes. 3*6 matrix, one column per vertex.
gauss: Gauss quadrature structure in isoparametric coordinates. Includes
the points, and the values and gradients of the shape functions there.
C: compliance matrix. 6*6.
eps0: pre-strain at each vertex (calculated from thermal expansion).
6*6, one column for each vertex. Each column is a 6-vector
representing a 3*3 symmetric tensor.
MorphogenViewer.m
J.Andrew Bangham CMP, UEA, 2008.
MoveStagesToProject.m
MoveStagesToProject(ProjectDirectory) Move 'stage' files resulting from a run conducted on a remote cluster machine into the project whose directory is ProjectDirectory, replacing any existing stage files there. The files to be copied are assumed to reside in directories of the form [ProjectDirectory]/runs/[experimentname]/meshes. The folder [ProjectDirectory]/runs/[experimentname] is also assumed to contain a file called 'CommandLine.txt'. The presence of this file is what tells this procedure that [ProjectDirectory]/runs/[experimentname] is an experimental results directory. If there is more than one such directory, the user is asked to choose one, each being identified to the user by the first line of its CommandLine.txt file. The result is empty in case of any problems, otherwise a positive number (whose value is not otherwise meaningful). When there is a problem, a message will be printed to the Matlab command window. J.Andrew Bangham 2008
NormaliseGrad.m
function signal=NormaliseGrad(signal,localmask,wholemask) normalise a morphogen gradient found in signal and in a region localmask so that its values lie in the range 0 to 1 Set all values outside the region specified by wholemask to 0 J.A.Bangham 2009
OrthotropicStiffnessMatrix.m
PrismJacobian.m
j = PrismJacobian( v, p ) Calculate the Jacobian of the
transformation from p = (xi,eta,zeta) to (x,y,z) for a triangular
prism with vertices v.
v is 3*6, each point being a column of v.
PrismJacobians.m
j = PrismJacobians( v, p ) Calculate the Jacobian of the
transformation from p = (xi;eta;zeta) to (x,y,z) for a triangular
prism with vertices v.
v is 3*6, each point being a column of v.
p may be a 3*n array: a Jacobian will be computed for each column of
p, and J will be a 3*3*n array.
If v is 3*6*m, J will be a 3*3*nm array.
ReconcileFields.m
function [s1]=ReconcileFields(s1,s2) Recursively find all fields in s2 that do not exist in s1 then create them as empty fields in s1 to ensure two structures have the same fields call the function twice, i.e. s1=ReconcileFields(s1,s2); s2=ReconcileFields(s2,s1) J.Andrew Bangham, 2008
ReplaceMorphogensInProject.m
function ReplacemorphogensInProject(FileName)
Filename, *.morphogens.txt is a text file containing
a list of morphogens to replace those in an existing
project
File format
MorphogenName [,diffusion constant[,decay rate]]
will generate id_MorphogenName
and s_MorphogenName with associated properties
when no diffusion and decay constants only the id_ will be formed
RunGFtboxSilently.m
runs SilentGFtbox having ensured that paths to the DArT_Toolbox are present.
RunModels.m
function RunModels(ExperimentNumber,ProjectName) Runs GFtbox modelling experiments without a user interface View the results using the program: VMS ExperimentNumber, experiment ExperimentNumber should be programmed into the switch ProjectName, default 'sd-pd-ls-200807-19a' J.Andrew Bangham, 2008
RunSilent.m
runs SilentGFtbox having ensured that paths to the DArT_Toolbox are present.
SemiOrthotropicStiffnessMatrix.m
SilentGFtbox.m
function SilentGFtbox(ProjectName,Directory,number_steps,stepsize)
For running growth models in batch mode. Results are filed in a
subdirectory
ProjectName:Movies:experimentname:meshes stores full mesh .mat files
At the end of each stage/step the mesh is stored in a separate file.
In addition, the command line used to invoke SilentGFtbox
and a copy of the interaction function are saved in the experimentname directory.
The meshes can be viewed using VMS (View Mesh System)
or VMSReport. They can also be moved into the project directory where
GFtbox will recognise them as 'Stages'.
When running jobs on the cluster, SilentGFtbox will automatically
log the fact with a program called ClusterControl.
To run on the cluster you must have
1) (UEA) Cluster username
2) Password
3) email address
and the following programs installed on your computer
4) WinSCP
5) Putty
6) pscp
7) plink
There is an option to output a set of shell scripts (.sh files) that
enable the results to be computed on a cluster in parallel.
This is invoked by the 'Use','Cluster', command pair.
Usage, all argument pairs are optional
SilentGFtbox(...
'State','RunNow',... % status of command, options are:
% default is 'RunNow', i.e. when 'State' is not used then
% system is run on the current computer
%
% The following only apply to running on the cluster
% 'Run' create and run a single command
%
% 'Begin' to begin assembling a batch of commands
% 'Add' to add to the existing batch
% 'Start' to add to and then run batch of commands
%
'Use','Cluster' % use the cluster if it is accessible
% default is not to use the cluster
'Name','IMotif2a',... % project to be run
'Dir', pwd,... % present working directory
either specify the modelling time in steps or stages
'dt',[],... % default value is set by the project itself
% this command is used to change dt
Using time
'Stages',[80,120,...] % default, output at every iteration
% list of stages (in hours) that are to be
% output.
% Overrides Stepsize.
% Overrides total_time, i.e. total_time=max(stages)
% stage filenumbers are time - consistent
% GFtbox
'Total_time',tvalue,...% i.e. number_steps = tvalue/dt, also see Stages
Using steps
'N_steps', 20,... % number of steps to be run
'Stepsize',1,... % interval between steps that are recorded
% overridden by Stages
% defaut 1
'Flatten',true or false,...% The mesh will be dissected, (edges to be dissected must
% be entered into the mesh using the GUI).
% The mesh will then be dissected,exploded and flattened.
% after the last step (or stage).
% it can take a long time.
'Mut_list',{'cych','div'},...% cell array of morphogen names to be set
% to zero activity
% default is 'wildtype' i.e. all morph_a=1
'param',[indices] % it is possible to automatically
%create set of experiments that systematically vary parameters
%of the model. These have to be setup inside the interaction
%function. e.g. the parameter called 'param' is set up with
%m.userdata.ranges.param.range=[0, 1.2, 5, 10]
%m.userdata.ranges.param.index=3; % this sets the default, i.e.
%param=5. By setting an invalid index using
%on the SilentGFtbox command line, i.e. 10
in this case, each value of the parameter
will be used. If two range parameters are
set then the combinations will be run as
separate jobs, i.e. if there were 4 and 5
alternatives respectively, 20 experiments
would be created.
%Sensitivity testing
%m.userdata.ranges.sensitivity.range
%m.userdata.ranges.sensitivity.index
this is a reserved userdatat ranges field
that is recognised by SilentGFtbox. In
To perform a sensitivity test, there must
be set of obj files in a directory called
objs. One obj per time step.
It is differences between the test sensitivity values
and these obj files that will be computed.
that will
'Subdiv',false, % default, false,
% true then FE model will be subdivided
% to four times the number of vertices at the beginning
%
'ClearPasswords','All',% The first time SilentGFtbox is run by a user on
% a particular computer, passwords are requested
% which are encrypted and saved
% It may be easier to configure passwords
% etc. by the command sequence ...
% clearpasswords
% getyouremail
% getyourclusterdirectory
% getpassword
% getyourclustername
'ExpID',name, % not for general use. Used internally by SilentGFtbox
% to label experiments as they are run on
% the cluster
e.g.
To make full use of the program, ClusterControl, please put the
projects in a directory called 'clusterstuff'
Run on personal computer
SilentGFtbox('Name','HoleMotif4','Stages',[5,15,25]);
Run on cluster, exploring two range parameters
SilentGFtbox('Name','HoleMotif4','Stages',[5,15,25],'wound_production',3,'growth',1,'Use','Cluster');
Run on cluster, exploring the effect of different dt and number of
vertices
SilentGFtbox('State','Begin','Name','NewFig4','dt',1.0,'Stages',[2,5,7],'Use','Cluster');
SilentGFtbox('State','Add','Name','NewFig4','dt',0.1,'Stages',[2,5,7],'Use','Cluster');
SilentGFtbox('State','Add','Name','NewFig4','dt',1.0,'Subdiv',true,Stages',[2,5,7],'Use','Cluster');
SilentGFtbox('State','Start','Name','NewFig4','dt',0.1,'Subdiv',true,'Stages',[2,5,7],'Use','Cluster');
J.Andrew Bangham, 2008
if isunix
% then assume it is running on the cluster and the paths are to be
% setup relative to the current directory
pathnames=fullfile(pwd,'DArT_Toolshed');
addpath(genpath(pathnames));
end
StandardPrism.m
v = StandardPrism() Return the vertexes of a standard triangular prism.
Steps.m
SubPhase.m
To allow subphases to be specified within the interaction function. As each stage is encountered a structure is built that can be used to pass stage specifications to the GFtbox. This then appears on the Stages menu. realtime, StC the data structure to be elaborated duration the time to be spent on this activity headingstr, the stage label counter, the stage counter. These should start at 1 and increment with each call iteraction counter, = m.currentiteration used to control initialisation State, true if realtime lies within this activity J.Andrew Bangham, 2009
TMIndex.m
TimedAdd.m
a=TimedAdd(realtimeNow,realtimeStart,realtimeStop) a=1 if start<=realtime<stop else a=0
TimedMul.m
a=TimedMul(realtimeNow,realtimeStart,realtimeStop) a=value if start<=realtime<stop else a=1
TransformModuli.m
TransformTensor.m
VMS.m
VMS(arg,options)
VMSReport.m
VMSReport(varargin)
Produce a printed report on results from running SilentGFtbox
before it finishes it invites you to rotate the figures
(rotate one using the sliders and the others follow suit)
it then invites you to print everything
Arguments come in command,value pairs
'Path', path to project default, pwd (default);
'Project', name of project in the path
'Experiment', either 'All' (the default) where all the experiments in
path/project/movies/result_directory/*
are compiled into a printed report
or {'experiment_name','experiment_name',...}
'MORPHOGEN','name' default 'Polariser'
'DRAWEDGES',integer, default 0 none, 1 outside edges only, 2 all edges
'DRAWGRADIENTS',logical default true
'THICK',logical default true
'DRAWSECONDLAYER',logical default false (cell layer)
'PRINT',logical default false
'VISIBLE',logical default true if true do not display figures
'ROTATION',[azimuth,elevation] default is as stored in project
'CELLS',logical default true
'STEREO',logical default false
usage
VMSreport('Project','HoleMotif4')
J. Andrew Bangham 2008
VRMLparams.m
VRMLPARAMS M-file for VRMLparams.fig
VRMLPARAMS, by itself, creates a new VRMLPARAMS or raises the existing
singleton*.
H = VRMLPARAMS returns the handle to a new VRMLPARAMS or the handle to
the existing singleton*.
VRMLPARAMS('CALLBACK',hObject,eventData,handles,...) calls the local
function named CALLBACK in VRMLPARAMS.M with the given input arguments.
VRMLPARAMS('Property','Value',...) creates a new VRMLPARAMS or raises the
existing singleton*. Starting from the left, property value pairs are
applied to the GUI before VRMLparams_OpeningFcn gets called. An
unrecognized property name or invalid value makes property application
stop. All inputs are passed to VRMLparams_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
ab_from_kbend.m
[a,b] = ab_from_kbend( k, bend ) Given growth K and bending BEND, compute the equivalent surface growths A and B, such that K-BEND = A and K+BEND = B. If allownegative is false, A and B are forced to be nonnegative, at the expense of violating the equalities. The default is that negative values are allowed.
addAIHgrowthdata.m
formatTest = max((1+abs(growthparams(:,1))) ./ (0.01+abs(growthparams(:,2))));
addCell.m
m = addCell( m, a, b, c ) Add to m a cell whose corners are the existing vertexes a, b, and c. No error checking is done; it is assumed that the operation is sensible. a and b, and a and c, are assumed to be connected by edges, and b-a-c is assumed to be the positive orientation.
addProjectsMenu.m
handles = addProjectsMenu( handles, projectsDir, readonly, callback ) projectsDir is a folder to be added to the Projects menu.
addStages.m
[times,fromold,fromnew] = addStages( oldtimes, newtimes ) Combine the lists of times, striking out duplicates and putting them into sorted order. fromold and fromnew are bitmaps of the result, showing which elements came from which list. oldtimes and newtimes do not have to already be sorted, and they may contain duplicates.
addStaticData.m
m = addStaticData( sd ) sd contains the static mesh data. Overwrite the static data in m by sd and reconcile them. This mostly consists of replacing fields in m by fields in sd, but the morphogen dictionary is shared by both and any changes require reindexing the per-morphogen fields of m.
addToNormal.m
m = addToNormal( m, addn, absolute ) addn is a vector containing one value per node of m. If absolute is true, then each node is displaced normal to the surface by that amount. If absolute is false (the default), then each node is displaced normal to the surface by that proportion of the thickness at that point.
addToRawMesh.m
addToZ.m
addinternalrotation.m
m = addinternalrotation( m, angle )
addmesh.m
m = addmesh( m, m1 ) Combine two meshes which contain only nodes and tricellvxs.
addmovieframe.m
movieobj = addmovieframe( movieobj ) Add a frame to a movie object created by either avifile or VideoWriter.
addquad.m
m = addquad( m, i, j, k, l ) m contains only m.nodes and m.tricellvxs. Add two cells to m.tricellvxs, which tringulate the quadrilateral i j k l.
addquadstrip.m
addrandomfield.m
mesh = addrandomfield( mesh, amount, whichMgen, smoothness, add ) Add a random amount of growth factor to every point.
addtrianglestrip.m
allCellFlatDisplacements.m
displacements = cellFlatDisplacements( normal, vxs ) Calculate the displacements of the vertexes of the cell from a right prism.
angle3.m
theta = angle3( v ) v is a 3*3 matrix [A;B;C]. The result is the angle
ABC.
anisotropy.m
a = anisotropy( pp ) Calculate the anisotropy from parallel and perpendicular growth. This is zero when both are zero, otherwise (par-perp)/(par+perp).
anisotropyFromParPerp.m
announceSimStatus.m
announceSimStatus( handles ) Update the report of leaf size, number of iterations, etc. in the GUI display.
announceview.m
applyMgenDefaults.m
m = applyMgenDefaults( m, mgenindexes, numnodes ) Insert default per-morphogen values for various fields, for the given set of new morphogen indexes. The indexes are assumed to be at the end of all current indexes.
applyMutations.m
arealGrowth.m
g = arealGrowth( pp ) Calculate the areal growth rate from parallel and perpendicular growth. This is their sum.
arealTensorGrowth.m
g = arealGrowth( t ) Compute the total growth rate of a two-dimensional growth tensor.
askForLegendDlg.m
Begin initialization code - DO NOT EDIT
askForLegend_getDefault.m
askForNameDesc.m
askForTimeUnit.m
s = askForTimeUnit() Put up a modal dialog asking for the name of the time unit.
attemptInteractionFunction.m
averageConductivity.m
d = averageConductivity( m, morphogenindex )
d = averageConductivity( c )
The first type of call translates to the second:
d = averageConductivity( m.conductivity(morphogenindex) )
Make a crude estimate of the average conductivity given by c.Dpar and
c.Dper. This is accurate when the conductivity is uniform, but should
not be used for numerical computation if it is non-uniform, only for
giving a rough estimate.
c can be a struct array, and morphogenindex can be an array of
indexes. d will be an array of average conductivities of the same
length.
averageMeshThickness.m
avpolgrad.m
apg = avpolgrad( m, ci, bc, vx, sparsedistance ) Calculate the average polarisation gradient over all of the finite elements, all of whose vertexes are within a distance sparsedistance of vx.
axesFromCell.m
axes = axesFromCell( vxs )
Compute a frame of reference for a triangular prism cell.
One axis is parallel to the xi isoparametric coordinate, one
is perpendicular to xi in the xi-eta plane, and the third is
perpendicular to both. Its direction should roughly coincide with the
zeta axis.
The vectors vxs are assumed to be column vectors. There must be 6 of
them: vxs(1:3) are the bottom face and vxs(4:6) are the top face.
axisrangeFromDialog.m
azelDlg.m
Begin initialization code - DO NOT EDIT
b3weights.m
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\growth\bio
in_lin.m
x = in_lin( k, m ) Calculate the inhibitory effect of morphogen m with scale factor k.
inh.m
x = inh( k, m ) Calculate the inhibitory effect of morphogen m with scale factor k. The morphogen and the scale are forced to be non-negative.
pro.m
x = pro( k, m ) Calculate the promoting effect of morphogen m with scale factor k. The morphogen and the scale are forced to be non-negative.
blankColorBar.m
blueRedCmap.m
borderedgemap.m
edgemap = borderedgemap( m, cellmap ) M is a mesh. CELLMAP is a boolean map pf cells. All of the border edges of the set of cells are found, that is, every edge which has one of the given cells on exactly one side. The set of edges is returned as a boolean map. If you need an array of indexes, call borderedges( m, cellmap ). See also: borderedges
borderedges.m
edges = borderedges( m, cellmap ) M is a mesh. CELLMAP is a boolean map pf cells. All of the border edges of the set of cells are found, that is, every edge which has one of the given cells on exactly one side. The set of edges is returned as an array of edge indexes. If you need a boolean map, call borderedgemap( m, cells ); See also: borderedgemap
borderingCells.m
boundingbox.m
bb = boundingbox( m, extra ) Calculate the bounding box of the mesh m, in a form that can be passed to axis(). If extra is specified, the box is expanded by this amount, e.g. if extra = 0.1 then the box will be 10% large than the exact bounds of the mesh.
buildMorphogenDict.m
m = buildMorphogenDist( m ) Build a dictionary mapping morphogen names to indexes and vice versa. Make sure the standard morphogens are included.
butterfly.m
[pos,prismpos] = butterfly( m, ei ) Find the location of the point resulting from subdividing edge ei by the butterfly algorithm.
butterfly3.m
pos = butterfly3( m, ci, bc, tension ) Generalises the butterfly algorithm to pick a point corresponding to the point in cell ci with barycentric coordinates bc. The resulting surface is continuous but not smooth across edges and vertexes.
butterflyPoints.m
[vxs,weights] = butterflyPoints( m, ei, tension ) Find the points and weights associated with subdividing edge ei by the butterfly algorithm.
butterflystencil.m
[wts,pts] = butterflystencil( m, ei ) Find the stencil resulting from subdividing edge ei by the butterfly algorithm.
calcBioACellAreas.m
calcN.m
vn = calcN( p ) Calculate the value of all the
shape functions for a triangular prism at isoparametric
coordinates p. The result is a row vector.
p is a 3-element column vector. It may also be a 3*N matrix, in which
case the result will be a 6*N matrix.
calcNewMorphogens.m
calcOldMorphogens.m
calcPolGrad.m
m = calcPolGrad( m ) Calculate the polarising gradients for growth and bending in the specified cells of the mesh, by default all of them.
calcmeshareas.m
m = calcmeshareas( m ) Calculate the area of every cell of the mesh.
calcnodeareas.m
nodeareas = calcnodeareas( m ) For each node, calculate the area of all of the cells containing that node.
calculateOutputs.m
m = calculateOutputs( m )
Calculate all of the tensors for specified/actual/residual growth on
the A/B sides, and the rotations. This creates the following
components of m:
m.outputs.specifiedstrain.A
m.outputs.specifiedstrain.B
m.outputs.actualstrain.A
m.outputs.actualstrain.B
m.outputs.residualstrain.A
m.outputs.residualstrain.B
m.outputs.rotation
Each of these is a per-FE quantity. If there are N finite elements,
then the tensor fields are N*6 and the rotations field is N*3. These
are all rates of growth or rotation, not absolute amounts.
Take the average of an A and a B quantity to get the value for the
midplane; take half of B-A to get the bending component.
To convert tensors to principal components, write for example:
[amounts,frames] = tensorsToComponents( m.outputs.actualstrain.A );
amounts will then be the principal components of actual growth on the
A side, listed in descending order. If you want them listed in the
order parallel, perpendicular, and normal, replace the second line by:
[amounts,frames] = tensorsToComponents( m.outputs.actualstrain.A, m.cellFrames );
To resolve rotation vectors into rotation about the normal vector and
the remainder, write:
[inplane,outofplane] = splitVector( m.outputs.rotations, m.unitcellnormals );
inplane will be a column of scalars, the rotation rates around the
normal vectors, and outofplane will be an N*3 matrix of vectors in the
planes of the respective finite elements.
To convert any per-element quantity to a per-vertex quantity, call:
perVxQuantity = perFEtoperVertex( m, perFEquantity );
The per-element quantity can be an N*K matrix, where N is the number of
finite elements. perVxQuantity will then be M*K where M is the number
of vertices.
callbackWaypoints.m
canvasColorsDlg.m
CANVASCOLORSDLG M-file for canvasColorsDlg.fig
CANVASCOLORSDLG by itself, creates a new CANVASCOLORSDLG or raises the
existing singleton*.
H = CANVASCOLORSDLG returns the handle to a new CANVASCOLORSDLG or the handle to
the existing singleton*.
CANVASCOLORSDLG('CALLBACK',hObject,eventData,handles,...) calls the local
function named CALLBACK in CANVASCOLORSDLG.M with the given input arguments.
CANVASCOLORSDLG('Property','Value',...) creates a new CANVASCOLORSDLG or raises the
existing singleton*. Starting from the left, property value pairs are
applied to the GUI before canvasColorsDlg_OpeningFcn gets called. An
unrecognized property name or invalid value makes property application
stop. All inputs are passed to canvasColorsDlg_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
cell3DCoords.m
v = cell3DCoords( mesh, ci, bc ) Find the 3D coordinates of the point with barycentric coordinates bc in cell ci.
cellBaryCoords.m
bc = cellBaryCoords( mesh, ci, v ) Find the barycentric coordinates of v in cell ci. v must be a single vector.
cellClick.m
handles = cellClick( handles, ci, bc, pt, selectionType ) Handle a click on element ci at barycentric coordinates bc and global coordinates pt. This should only be called when the simulation is not running.
cellFlatDisplacements.m
displacements = cellFlatDisplacements( normal, vxs ) Calculate the displacements of the vertexes of the cell from a right prism.
cellListFromNodeMap.m
cells = cellsfromnodemap( m, nodes, mode ) M is a mesh. NODES is either an array of node indexes or a boolean map of nodes. If MODE is 'all', find every finite element for which every vertex is in the set of nodes; if 'any', every finite element with at least one vertex in the set. The set of cells is returned as an array of indexes. If you need a boolean map of the cells, call cellMapFromNodeMap( m, nodemap, mode ). See also: cellMapFromNodeMap
cellMapFromEdgeMap.m
cellmap = cellMapFromEdgeMap( m, edgemap, mode ) M is a mesh. EDGE is a boolean map of edges or an array of edge indexes. If MODE is 'all', find every finite element for which every edge is in the set of nodes; if 'any', every finite element with at least one edge in the set. The set of cells is returned as a boolean map. If you also need an array of indexes, apply FIND to it. If you only need an array of indexes, call cellsFromEdgeMap( m, nodes, mode ); See also: cellsFromEdgeMap
cellMapFromNodeMap.m
cellmap = cellmapfromnodes( m, nodemap, mode ) M is a mesh. NODEMAP is an array of node indexes. If MODE is 'all', find every finite element for which every vertex is in the set of nodes; if 'any', every finite element with at least one vertex in the set. The set of cells is returned as a boolean map. If you also need an array of indexes, apply FIND to it. If you only need an array of indexes, call cellListFromNodeMap( m, nodes, mode ); See also: cellListFromNodeMap
cellToVertex.m
vertexStuff = cellToVertex( mesh, cellStuff ) Convert a quantity defined per cell to a quantity defined per vertex. The vertex value is the average of all the cell values for cells that the vertex belongs to.
cellToVx.m
vxstuff = cellToVx( mesh, cellstuff ) From an array of stuff-per-cell, construct an array of stuff-per-vertex, setting the quantity at each vertex to be the average of the quantity at each cell the vertex belongs to. The tricellvxs component of the mesh is assumed to be valid.
cellVectorGlobalToLocal.m
lv = cellVectorGlobalToLocal( m, gv )
GV contains one vector per finite element of M in global coordinates.
LV is the corresponding vector field expressed in local coordinates for
each cell. That is, for every i, LV(i,:) sums to zero, and subject to
that, the following equality is satisfied as closely as possible:
gv(i,:) = lv(i,:) * m.nodes(m.tricellvxs(i,:),:)
SEE ALSO: cellVectorLocalToGlobal
cellVectorLocalToGlobal.m
gv = cellVectorLocalToGlobal( m, lv )
LV contains one vector per finite element of M in local cell coordinates.
GV is the corresponding vector field expressed in global coordinates.
That is, for every i:
gv(i,:) = lv(i,:) * m.nodes(m.tricellvxs(i,:),:)
SEE ALSO: cellVectorGlobalToLocal
cellcentres.m
cc = cellcentres( m, cells, side ) Find the centres of all the finite elements, on either the A side, the B side, or the midplane. side==-1 is the A side, 0 is the midplane, and 1 is the B side. If side is omitted, it is determined from the plotting options.
cellcoords.m
coords = cellcoords( mesh, ci ) Return the coordinates of the three vertexes of triangular cell ci.
cellneighbours.m
cellnormal.m
normal = cellnormal( mesh, ci ) Calculate the normal vector to element ci of the mesh. The length of the vector is twice the area of the cell. ci can be a vector; the result will be an N*3 array.
cellsFromEdgeMap.m
cells = cellsFromEdgeMap( m, edgemap, mode ) M is a mesh. EDGE is a boolean map of edges or an array of edge indexes. If MODE is 'all', find every finite element for which every edge is in the set of nodes; if 'any', every finite element with at least one edge in the set. The set of cells is returned as a boolean map. If you also need an array of indexes, apply FIND to it. If you only need an array of indexes, call cellMapFromEdgeMap( m, nodes, mode ); See also: cellMapFromEdgeMap
cellvorticities.m
centremesh.m
m = centremesh( m ) Translate the mesh m so that the midpoint of the range of its node positions is at the origin.
cgsmsg.m
checkVoronoiAngles.m
checkVoronoiAngles( V, P ) [V,P] is the output of VORONOIN(...): V is the set of vertexes of the Voronoi network, and P the set of vertex lists that define the cells. For every vertex in V, if there are N edges meeting at the vertex, where N >= 3, then the angles between them should be 2pi/N. Calculate the average deviation from that figure over the whole network. This can be used as a measure of non-centroidality of the network. When the CVT algorithm is run, it typically converges from an initial error value of about 0.5 for a random set of Voronoi generators to about 0.2, that is, from about 30 degrees to about 12 degrees. If P is not given, V is assumed to be a set of Voronoi generators, and the Voronoi network is first calculated from them.
chooseColorMap.m
citation_Callback.m
citation_Callback(hObject, eventdata) Display a citation of our papers.
clearFlag.m
clearpasswords.m
clipmgenDlg.m
clipmgenDlg M-file for clipmgenDlg.fig
clipmgenDlg, by itself, creates a new clipmgenDlg or raises the existing
singleton*.
H = clipmgenDlg returns the handle to a new clipmgenDlg or the handle to
the existing singleton*.
clipmgenDlg('CALLBACK',hObject,eventData,handles,...) calls the local
function named CALLBACK in clipmgenDlg.M with the given input arguments.
clipmgenDlg('Property','Value',...) creates a new clipmgenDlg or raises the
existing singleton*. Starting from the left, property value pairs are
applied to the GUI before clipmgenDlg_OpeningFunction gets called. An
unrecognized property name or invalid value makes property application
stop. All inputs are passed to clipmgenDlg_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
closemovie.m
movieobj = closemovie( movieobj ) Close a movie, whether it was created with avifile or VideoWriter.
combineDFs.m
dfs = combineDFs( x, y, z )
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\growth\commands
leaf_add_mgen.m
m = leaf_add_mgen( m, mgen_name, ... )
Add a new morphogen to m with the given name. If there is already a
morphogen with that name, this command is ignored. Any number of names
can be given at once.
Equivalent GUI operation: the "New" button on the "Morphogens" panel.
A dialog will appear in which the user chooses a name for the new
morphogen.
See also:
leaf_delete_mgen, leaf_rename_mgen
Topics: Morphogens.
leaf_add_userdata.m
m = leaf_add_userdata( m, ... ) Add fields to the userdata of m. The arguments should be alternately a field name and a field value. Existing fields of those names in m.userdata will be left unchanged. See also: leaf_set_userdata, leaf_delete_userdata. Equivalent GUI operation: none. Topics: User data
leaf_addpicture.m
m = leaf_addpicture( m, ... )
Create a new picture window to plot the mesh in. This is primarily
intended for plotting the mesh in multiple windows simultaneously.
Options:
'figure' A handle to a window. The previous contents of the
window will be erased.
'position' An array [x y w h] specifying the position and size of the
window relative to the bottom left corner of the screen.
x is horizontal from the left, y is vertical from the
bottom, w is the width and h is the height, all in pixels.
'relpos' A similar array, but this time measured relative to the
bottom left corner of the previous picture, if there is
one, otherwise the bottom left corner of the screen.
Only one of position or relpos may be supplied.
w and h can be omitted from relpos, in which case the size defaults
to the size of the existing window, if any, otherwise the default
size for a new window.
x and y can be omitted from position, in which case the new window
is centred on the screen.
If both position and relpos are omitted, a window of default size
and position is created.
'vergence' A number in degrees, default 0. The view direction of
the figure is offset by this amount, so that the eye
seeing the figure sees it as if the eye was turned
towards the centre line by this angle.
'eye' 'l' or 'r', to specify which eye this is for.
If no eye is specified, vergence defaults to zero. If
vergence is specified, an eye must also be specified.
'properties' A structure containing any other attribute of the
figure that should be set.
Topics: Plotting, Stereo.
leaf_addseam.m
m = leaf_addseam( m, ... )
Marks some edges of m as being or not being seams, according to
criteria given in the options. Unlike most other toolbox commands, the
options to this command are processed sequentially and the same option
may occur multiple times in the list.
Options:
'init' Either 'all' or 'none'. Sets either all of the edges,
or none of them, to be seam edges.
'edges' An array of edge indexes. All of these edges will
become seam edges.
'nonedges' An array of edge indexes. All of these edges will
become non-seam edges.
'nodes' An array of node indexes. All edges joining two nodes
in this set will become seam edges.
'nonnodes' An array of node indexes. All edges touching any node
in this set will become non-seam edges.
'edgemap', 'nonedgemap', 'nodemap', 'nonnodemap':
As above, but these are arrays of booleans specifying
the edges of nodes to be included or excluded from the
seams.
'morphogen' A cell array of two elements. The first is a
morphogen name or index. The second is a string
specifying how the value of the morphogen will be used
as a criterion for deciding whether an edge should
become a seam. It consists of three parts. It begins
with one of 'min', 'mid', or 'max'. This is followed
by one of '<', '<=', '>=', or '>'. This is followed by
a number. Examples: 'min>0.5' means that an edge
becomes a seam if the minimum value of the morphogen at
either end is greater than 0.5. 'max' would take the
maximum of the ends, and 'mid' would take the average.
Example:
m = leaf_addseam( m, 'init', 'none', ...
'nodemap', m.morphogens(:,12) > 0.1 );
Topics: Mesh editing, Seams.
leaf_addwaypoint.m
Add a waypoint to m. A waypoint stores the current plotting options,
the simulated time, and the options given to this procedure. The
waypoints are states of the mesh that form keyframes for a movie. Once
all of the desired waypoints have been created, a movie can be
generated by leaf_waypointmovie which begins at the first waypoint
continues through all of them to the last. Between waypoints
iterations of the simulation can be performed, the viewpoint smoothly
changed, plotting options can change, the plotting options themselves
can be smoothly interpolated between waypoints.
OPTIONS:
'name' A name for the waypoint. This is optional, and is only used
in the dialog for editing the waypoint list.
'frames' The number of frames to be generated from the previous
waypoint to the current one, including the current but not
the previous. If simulated time has elapsed since the ;ast
waypoint, the simulation step will be adjusted to fit.
'timestep' You can spcify this instead of the number of frames, if
some simulated time has elapsed since the last waypoint.
'spin' The number of revolutions of spin that should be performed
in the interval since the last waypoint.
'tilt' The number of cycles of up and down tilting of the
viewpoint that should be performed in the interval since
the last waypoint.
'crossfade' Whether the non-interpolable plotting options should be
cross-faded in this segment of the movie, or be applied
only on the last frame.
See also leaf_waypointmovie, leaf_clearwaypoints.
Topics: Movies/Waypoints.
leaf_allowmutant.m
m = leaf_allowmutant( m, enable )
Enable or disable the whole mutation feature. When enabled, all mutant
levels of morphogens will be active. When disabled, the tissue will
grow as the wild type.
Arguments:
enable: 1 or true to allow mutation, 0 or false to disable mutation.
Topics: Morphogens, Mutation.
leaf_alwaysflat.m
m = leaf_alwaysflat( m, flat )
If FLAT is 1, force the mesh to never bend out of the XY plane. The
mesh will be flattened if it is not already flat, by setting the Z
coordinate of every node to zero.
If FLAT is 0, allow the mesh to bend out of the XY plane. If the mesh
happens to be flat, it will not actually bend unless it is perturbed
out of the XY plane, e.g. by adding a random Z displacement with the
leaf_perturbz command.
A flat mesh is still allowed to vary in thickness.
Example:
m = leaf_alwaysflat( m, 1 );
Equivalent GUI operation: clicking the "Always flat" checkbox on the
"Mesh editor" panel.
Topics: Mesh editing, Simulation.
leaf_archive.m
m = leaf_archive( m ) Create an archive of the current state of the project. Archived states are kept in a subfolder ARCHIVE of the current project. Each archived state is in a project folder whose name is the name of the current project, with '_Ann' appended, where nn is a number 1 greater than the maximum number that has already been used, or 1 for the first created archive. Arguments: none. Equivalent GUI operation: clicking the "Archive" button. INCOMPLETE -- DO NOT USE. Topics: HIDE, Project management.
leaf_attachpicture.m
m = leaf_attachpicture( varargin ) NOT SUPPORTED. INCOMPLETE. NON-OPERATIONAL. Load a picture from a file. Create a rectangular mesh of the same proportions. If no filename is given for the picture, a dialog will be opened to choose one. Equivalent GUI operation: none. Topics: HIDE, Picture distortion.
leaf_bowlz.m
m = leaf_bowlz( m, ... )
Add a bowl-shaped perturbation to the z coordinate of every point of
the finite element mesh. The z displacement will be proportional to
the square of the distance from the origin of coordinates.
Arguments:
A number, being the maximum displacement. The displacement will be
scaled so that the farthest point from the origin is displaced by
this amount. The default is 1.
Examples:
m = leaf_bowlz( m, 2 );
Equivalent GUI operation: the "Bowl Z" button on the "Mesh editor"
panel. The amount of bowl deformation is specified by the value in the
upper of the two text boxes to the right of the button.
Topics: Mesh editing.
leaf_cellcentroids.m
cellcentroids = leaf_cellcentroids( m ) Compute the centroids of all of the biological cells, as an N*3 array.
leaf_circle.m
m = leaf_circle( m, ... )
Create a new circular mesh.
Arguments:
M is either empty or an existing mesh. If it is empty, then an
entirely new mesh is created, with the default set of morphogens.
If M is an existing mesh, then its geometry is replaced by the new
mesh. It retains the same set of morphogens (all set to zero
everywhere on the new mesh), interaction function, and all other
properties not depending on the specific geometry of the mesh.
Options:
'xwidth' The diameter of the circle in the x direction. Default 2.
'ywidth' The diameter of the circle in the y direction. Default 2.
'rings' The number of circular rings of triangles to divide
it into. Default 4.
'circumpts' The number of vertexes around the circumference.
The default is rings*6. It must be at least 4, and
for best results should be at least rings*4. As a
special case, if zero is specified, rings*6 is
chosen.
'innerpts' The number of vertexes around the innermost ring of
points. Default is max( floor(circum/nrings), 3 ).
'dealign' Dealign the vertexes on adjacent rings. Default
false. Only applies when circumpts is nonzero.
'coneangle' Make a circular cap of a sphere instead of a flat
circle. The surface can be defined as the
interscetion of the surface of a sphere with a cone
whose apex is at the centre of the sphere. The
value of coneangle is the angle between the axis of
the cone and the surface of the cone. The default
is zero, i.e. make a flat circle. If coneangle is
negative, the spherical cap is made in the -z
direction. coneangle should be between -PI and PI.
'height' Modify the height of the circular cap specified by
coneangle, by scaling the z-axis to make the height
of the centre of the cap above the plane of its rim
equal to the specified value. If coneangle is not
specified, and height is non-zero, then coneangle
defaults to PI/2. If coneangle is specified and
height is not, then height defaults to thevalue for
a spherical cap, i.e. height = radius(1 -
cos(coneangle), where radius = sqrt(xwidth*ywidth).
Example:
m = leaf_circle( [], 'radius', 2, 'rings', 4 );
Equivalent GUI operation: selecting "Circle" or "Hemisphere" on the
pulldown menu on the "Mesh editor" panel, and clicking the "Generate
mesh" button.
Topics: Mesh creation.
leaf_clearwaypoints.m
m = leaf_clearwaypoints( m ) Clear the waypoint list. See also leaf_addwaypoint, leaf_waypointmovie. Topics: Movies/Waypoints.
leaf_colourA.m
m = leaf_colourA( m )
Assign colours to all the cells in the biological layer. If there is
no biological layer, the values of the options are stored in m but the
command is otherwise ignored.
Optional arguments:
colors: The colour of the cells, as a pair of RGB values as a 2*3
array. The first is for the unshocked state and the
second for the shocked state.
colorvariation: The amount of variation in the colour of the new
cells. Each component of the colour value will be randomly
chosen within this ratio of the value set by the 'color'
argument. That is, a value of 0.1 will set each component
to between 0.9 and 1.1 times the corresponding component of
the specified colour. (The variation is actually done in
HSV rather than RGB space, but the difference is slight.)
The default is zero. A value of 1 or more will give
colours scattered over the entire colour space.
The values of the options are stored in the mesh, and the options
default to the stored values.
Topics: Bio layer.
leaf_computeGrowthFromDisplacements.m
[out1, out2, out3, out4] = leaf_computeGrowthFromDisplacements( m, displacements, time, ... )
Compute the growth rate in each FE of m given the displacements of all
the prism nodes and the time over which these displacements happened.
This assumes that m is in the state after these
displacements have happened. The results returned depend on the
options and on how many output arguments are given. Note that unlike
most leaf_* commands, m itself is not one of the output arguments,
since this procedure does not need to modify m.
The growth rates are returned as an N*3 matrix with one row for each
finite element. The ordering of the three values is determined by the
'axisorder' option.
If the displacement array is empty or the time interval is not
positive, then zeros will be returned.
Options:
'frames': a boolean. If true, then the frames of reference defining the
directions of growth will also be returned, as a 3*3*N matrix. The
axes of each 3*3 matrix are its columns. Their ordering is the same as
the ordering of growth rates. frames need only be specified when two
output arguments are given, since it is then required to disambiguate
which two output values the caller wants.
'axisorder': a string, one of 'parpernor' (the default), 'maxminnor',
or 'descending'. This determines the ordering of the growth rates and
axes at each point. 'parpernor' returns them in the order parallel to
the polariser gradient, perpendicular to it within the surface, and normal
to the surface. (To be precise, the "parallel" axis is the tensor axis
that is closest to being parallel to the gradient, "perpendicular" is
the closest to the perpendicular direction, and "normal" is orthogonal
to the other two.) 'maxminnor' also puts the rate normal to the surface
last, but of the first two it puts the largest value first.
'descending' puts all three values in descending order.
'anisotropythreshold': a non-negative number. Wherever the anisotropy
is less than this value, the growth rates returned will be set to zero.
Anisotropy is measured in terms of kmax (maximum in-surface growth
rate) and kmin (minimum in-surface growth rate) by the following
formula: (kmax-kmin)/kmax, or zero if kmax is zero. Anisotropy is zero
when growth is perfectly isotropic, and 1 where growth is in one
direction only. Pass a value of zero (the default) to allow all values
of anisotropy.
'exponential': The value of this option is a non-negative real number.
If zero (the default) the growth rate reported will be the amount of
growth divided by the time interval TO BE COMPLETED
If one output argument is given, then the result
will be the requested growth rates for each finite element.
If frames is true (the default) and two output arguments are given,
then the first result will be the requested growth rates for each
finite element, and the second will be the frames of reference.
If frames is false and two output arguments are given, then the first
result will be the growth rates for the A side of each finite
element, and the second result will be the rates for the B side.
If four output arguments are given, then the first
result will be the requested growth rates on the A side for each finite
element, the second will be the corresponding frames of reference, and
the third and fourth will be the growth rates and frames of reference
for the B side.
For example, to plot the parallel growth rate for a given set of
displacements from within the interaction function, one can write:
growth = leaf_computeGrowthFromDisplacements( m, displacements );
m = leaf_plotoptions( m, ...
'perelement', growth(:,1), 'cmaptype', 'monochrome' );
To use this to plot the growth that has taken place over some extended
time interval, you should at the beginning of that interval store the
current locations of all of the vertexes, e.g. like this:
if (we are at the start of the interval)
m.userdata.oldpositions = m.prismnodes;
m.userdata.starttime = m.globalDynamicProps.currenttime;
end
When it is time to calculate the growth, the growth rate parallel to
the polariser gradient can be calculated and plotted thus:
if (we are at the end of the interval)
displacements = m.prismnodes - m.userdata.oldpositions;
growth = leaf_computeGrowthFromDisplacements( m, displacements, ...
m.globalDynamicProps.currenttime - m.userdata.starttime );
m = leaf_plotoptions( m, ...
'perelement', growth(:,1), 'cmaptype', 'monochrome' );
end
For areal growth rate you would use growth(:,1)+growth(:,2).
CAUTIONS:
1. The above method of calculating growth over an interval requires
that no subdivision or transformation of the mesh have taken place
during that interval, otherwise m.prismnodes and
m.userdata.oldpositions may have different sizes.
2. The interaction function is called before growth is computed,
so the values plotted as a result of the above code will be one step
out of date. You can plot the up-to-date values by clicking the "Call"
button in GFtbox in order to just call the interaction function without
performing a growth step, but for this to be safe you must write your
interaction function in such a way that calling it twice in a row
always has the same effect as calling it once.
leaf_createmesh.m
m = leaf_createmesh( m, nodes, triangles )
Create a new mesh from a given set of vertexes and triangles.
Arguments:
M is either empty or an existing mesh. If it is empty, then an
entirely new mesh is created, with the default set of morphogens.
If M is an existing mesh, then its geometry is replaced by the new
mesh. It retains the same set of morphogens (all set to zero
everywhere on the new mesh), interaction function, and all other
properties not depending on the specific geometry of the mesh.
NODES is an N*3 matrix containing N points in 3D space. These are
the vertexes of the new mesh.
TRIANGLES is an M*3 matrix containing triples of indexes of points
in NODES. These must be consistently oriented.
All arguments must be present.
Options:
version: Specifies whether the standard morphogen set should be
A-side and B-side growth (the default, given by
version = 1), or growth and bend (given by version = 0).
Equivalent GUI operation: none.
Topics: Mesh creation.
leaf_cylinder.m
m = leaf_cylinder( m, ... )
Create a new surface, in the form of an open-ended cylinder whose axis
is the Z axis, centred on the origin.
Arguments:
M is either empty or an existing mesh. If it is empty, then an
entirely new mesh is created, with the default set of morphogens
If M is an existing mesh, then its geometry is replaced by the new
mesh. It retains the same set of morphogens (all set to zero
everywhere on the new mesh), interaction function, and all other
properties not depending on the specific geometry of the mesh.
Options:
'xwidth' The diameter of the cylinder in the X direction. Default 2.
'ywidth' The diameter of the cylinder in the Y direction. Default 2.
'centre' The position of the centre of the cylinder.
'height' The height of the cylinder. Default 2.
'circumdivs' The number of divisions around the cylinder.
Default 12.
'heightdivs' The number of divisions along the axis of the
cylinder. Default 4.
'basecap' Boolean. If true, the foot of the cylinder will be
closed by a hemispherical cap.
'baseheight' The height of the base cap as a fraction of the
radius of the cylinder. 1 will make it exactly
hemispherical, 0 will make it flat.
'baserings' The number of rings of triangles to divide the base
cap into. If zero, empty, or absent, a default
value will be chosen.
'topcap', 'topheight', 'toprings': Similar to basecap, baseheight,
and baserings.
Example:
m = leaf_cylinder( [], 'radius', 2, 'height', 2, 'circumdivs', 12,
'heightdivs', 4 );
See also: LEAF_CIRCLE, LEAF_LUNE, LEAF_ONECELL,
LEAF_RECTANGLE, LEAF_SEMICIRCLE.
Equivalent GUI operation: selecting "Cylinder" on the pulldown menu on
the "Mesh editor" panel, and clicking the "Generate mesh" button. The
radius, height, number of divisions around, and number of divisions
vertically are given by the values of the text boxes named "radius",
"y width", "x divs", and "y divs" respectively.
Topics: Mesh creation.
leaf_delete_mgen.m
m = leaf_delete_mgen( m, mgen_name, ... )
Delete from m the morphogen that has the given name. If there is no
such morphogen, or if the name is one of the reserved morphogen names,
this command is ignored. Any number of names can be given at once.
Equivalent GUI operation: clicking the "Delete" button in the
"Morphogens" panel, which deletes the currently selected morphogen.
See also:
leaf_add_mgen, leaf_rename_mgen
Topics: Morphogens
leaf_delete_userdata.m
m = leaf_delete_userdata( m, ... ) Delete specified fields from the userdata of m. The arguments should be strings. If no strings are given, all the user data is deleted. If a named field does not exist, it is ignored. See also: LEAF_SET_USERDATA, LEAF_ADD_USERDATA. Equivalent GUI operation: none. Topics: User data
leaf_deletenodes.m
m = leaf_deletenodes( m, nodes ) Delete from the leaf every finite element for which any of the nodes is a vertex. Arguments: nodes: A list of the nodes to delete, or a boolean map of the nodes which is true for the nodes to be deleted. Equivalent GUI operation: none. Topics: Mesh editing.
leaf_deletepatch.m
m = leaf_deletepatch( m, cells ) Delete the specified finite element patches from the leaf. Arguments: cells: A list of the cells to delete, or a boolean map of the cells which is true for the cells to be deleted. Equivalent GUI operation: clicking on the mesh when the "Delete canvas" item is selected in the "Mouse mode" pulldown menu. Topics: Mesh editing.
leaf_deletepatch_from_morphogen_level.m
function m=leaf_deletepatch_from_morphogen_level(m,wound) method for deleting a region of mesh specified by setting a morphogen (say 'wound') greater than 0.5. The value of 'wound' specified for all the vertices of the patch to be deleted must be set to greater than 0.5 (i.e. a patch is not specified by a single vertex - there must be at least three) Topics: Mesh editing.
leaf_deletesecondlayer.m
m = leaf_deletesecondlayer( m ) Delete the first biological layer. Equivalent GUI operation: clicking the "Delete all cells" button in the "Cells" panel. Topics: Bio layer.
leaf_deletestages.m
m = leaf_deletestages( m ) Delete all the stage files for m, and optionally, the stage times. Deleted files are gone at once, not put in the wastebasket. Options: 'times' Boolean. Default false. 'stages' Boolean. Default true. If 'stages' and 'times' are both true, then all stage files and stage times will be deleted. If 'stages' is true and 'times' is false, then the stage files will be deleted, but all stage times will be retained. If 'stages' is false and 'times' is true, then the stage files will be preserved, and all times will be deleted for which there is no stage file. If 'stages' and 'times' are both false, nothing happens. Equivalent GUI operation: the "Delete All Stages..." and "Delete Stages and Times" commands on the Stages menu. Topics: Project management.
leaf_destrain.m
m = leaf_destrain( m ) Remove all residual strain from the mesh. Equivalent GUI operation: clicking the "De-strain" button on the "Simulation" panel. Topics: Simulation.
leaf_dissect.m
m = leaf_dissect( m ) Cut m along all of its seam edges. Arguments and options: none. Topics: Mesh editing, Seams.
leaf_dointeraction.m
[m,ok] = leaf_dointeraction( m, enable )
Execute the interaction function once, without doing any simulation
steps. This will happen even if the do_interaction property of the mesh
is set to false,
If there is no interaction function, this has no effect.
If there is an interaction function and it throws an exception, OK will
be returned as FALSE.
Arguments:
enable: 1 if the interaction function should be enabled for all
subsequent simulation steps, 0 if its state of enablement should be
left unchanged (the default). If the i.f. throws an error then it
will be disabled for subsequent steps regardless of the setting of
this argument.
Topics: Interaction function.
leaf_edit_interaction.m
m = leaf_edit_interaction( m, ... )
Open the interaction function in the Matlab editor.
If there is no interaction function, create one.
Options:
'force' If true, the interaction function will be opened even
if the model m is marked read-only. If false (the
default) a warning will be given and the function not
opened.
Extra results:
ok is true if the function was opened, false if for any reason it
was not.
Topics: Interaction function.
leaf_enablelegend.m
m = leaf_enablelegend( m, enable )
Cause the legend to be drawn or not drawn.
When not drawn, the graphic item that holds the legend text will be
made invisible.
Arguments:
enable: A boolean specifying whether to draw the legend (default true).
Topics: Plotting.
leaf_enablemutations.m
m = leaf_enablemutations( m, enable )
Enable or disable mutations.
Arguments:
enable: True to enable all mutations, false to disable them.
Examples:
m = leaf_enablemutations( m, 0 );
% Disable all mutations, i.e. revert to wild-type.
Topics: Morphogens, Mutation.
leaf_explode.m
m = leaf_explode( m, amount )
Separate the connected components of m.
Arguments:
amount: Each component of m is moved so as to increase the distance
of its centroid from the centroid of m by a relative amount AMOUNT.
Thus AMOUNT==0 gives no movement and AMOUNT < 0 will draw the
pieces inwards.
Topics: Mesh editing.
leaf_fix_mgen.m
m = leaf_fix_mgen( m, morphogen, ... )
Make the current value of a specified morphogen at a specified vertex
or set of vertexes be fixed or changeable.
Arguments:
1: The name or index of a morphogen.
Options:
'vertex' Indexes of the vertexes. The default is the empty list
(i.e. do nothing).
'fix' 1 or true if the value is to be made fixed, 0 or false if
it is to be made changeable. The default is true.
Equivalent GUI operation: control-clicking or right-clicking on the
canvas when the Morphogens panel is selected.
Topics: Morphogens.
leaf_fix_vertex.m
m = leaf_fix_vertex( m, ... )
Constrain vertexes of the mesh so that they are only free to move along
certain axes; or remove such constraints.
Options:
'vertex' The vertexes to be constrained or unconstrained. If
the empty list is supplied, the set of all vertexes is
used.
'dfs' The degrees of freedom to be constrained. This is a
string made of the letters 'x', 'y', and 'z'. This
defaults to 'xyz', i.e. fix the vertexes completely.
Each degree of freedom not in dfs will be made
unconstrained for all of the given vertexes. Vertexes
not in the list of vertexes will have their constraints
left unchanged.
Note that to remove all constraints from all vertexes, do this:
m = leaf_fix_vertex( m, 'vertex', [], 'dfs', );
It is only possible to constrain vertexes in directions parallel to the
axes.
Invalid vertex indexes will be detected, warned about, and ignored. If
you receive such a warning you should check the indexes you are
supplying, since the fact of some of them being out of range may cast
doubt on the correctness of the others.
Equivalent GUI operation: clicking on the mesh while the Mesh editor
panel is selected and 'Fix' is selected in the mouse-mode menu. The
'x', 'y', and 'z' checkboxes specify which degrees of freedom to
constrain or unconstrain.
Topics: Mesh editing.
leaf_flatstrain.m
m = leaf_flatstrain( m ) Set the residual strains in the mesh to what they would be if the whole mesh were flat. Arguments: none. Options: none. Equivalent GUI operation: clicking the "Flat strain" button in the "Simulation" panel. Topics: Simulation.
leaf_flatten.m
[m,ok] = leaf_flatten( m )
Flatten each of the connected components of m.
Options:
interactive: If true (default is false), then the flattening will
be carried out interactively. The user can skip the
flattening of components that appear not to be well
flattenable, or cancel the whole operation.
method: One of the following:
'laplacian' (NOT IMPLEMENTED)
'geodesic' (NOT IMPLEMENTED)
'ballandspring' (the default)
getdeformation: Boolean. If true (the default), the deformation
to its that would restore the shape of each flattened element
original shape is calculated and stored in
m.celldata(:).cellThermExpGlobalTensor. If the leaf
is then grown with the property 'useGrowthTensors' set
to true, then in one unit of time its original shape
should be (approximately) restored.
bsiters: An integer. The maximum number of iterations to
perform in the ball-and-spring phase. If 0, the
ball-and-spring phase will be omitted.
The growth output argument is optional. If provided, it will be set to
a set of growth tensors, one per finite element, describing the
deformation from the flattened state to the original.
Topics: Mesh editing.
leaf_flattenByElasticity.m
m = leaf_flatten( m )
Flatten each of the connected components of m.
Options:
ratio: This is the proportion of the flattening displacements to
apply. The default value is 1, i.e. complete flattening.
Topics: OBSOLETE, Mesh editing.
leaf_fliporientation.m
m = leaf_fliporientation( m ) Interchange the two surfaces of the mesh. Topics: Mesh editing.
leaf_getimage.m
img = leaf_getimage( m ) Get an image of the current mesh. It will be forced to be the same size as the size stored in m.globalProps.framesize, unless that is empty, in which case m.globalProps.framesize will be set to the size of the captured image. This ensures that successive images are all the same size, which is essential when recording a movie. See also: leaf_movie. Topics: Movies/Images
leaf_getplotoptions.m
s = leaf_getplotoptions( m, ... ) Read the default plotting options. See LEAF_PLOT for details. The arguments are names of any plotting options that can be passed to LEAF_PLOT or LEAF_PLOTOPTIONS. The result is a structure whose fields are those option names and whose values are the values they have in m. Unrecognised options will be ignored. Unlike most leaf_* commands, this command does not modify m and therefore does not return a new value of m. See also: leaf_plot, leaf_plotoptions. Topics: Plotting.
leaf_getproperty.m
s = leaf_getproperty( m, ... ) Read various properties of the mesh. The arguments are any property names that can be passed to leaf_setproperty. The result is a structure whose fields are those names and whose values are the values they have in m. Unrecognised names will be ignored. Unlike most leaf_* commands, this command does not modify m and therefore does not return a new value of m. See also: leaf_setproperty. Topics: Misc.
leaf_gyrate.m
m = leaf_gyrate( m, ... )
Spin and/or tilt the mesh about the Z axis, leaving it at the end in
exactly the same orientation as when it started. If a movie is currently being
recorded, the animation will be appended to the movie. The current view
is assumed to have already been written to the movie.
Options:
'frames': The number of frames to be added. Default 32.
'spin': The number of complete rotations about the Z axis.
Default 1.
'waveangle': If zero (the default) spinning is in complete
revolutions. If non-zero, spinning consists of turning
right and left and back to centre. The initial
direction will be rightwards of waveangle is positive.
'tilt': The number of cycles of tilting up, down, and back to
the initial elevation. Default 1.
'tiltangle': The angle to tilt up and down to, in degrees from
the horizontal. Default 89.99.
Topics: Movies/Images, Plotting.
leaf_hemisphere.m
m = leaf_hemisphere( m, ... )
Create a new hemispherical mesh. The mesh is oriented so that the cell
normals point outwards.
Arguments:
M is either empty or an existing mesh. If it is empty, then an
entirely new mesh is created, with the default set of morphogens
If M is an existing mesh, then its geometry is replaced by the new
mesh. It retains the same set of morphogens (all set to zero
everywhere on the new mesh), interaction function, and all other
properties not depending on the specific geometry of the mesh.
Options:
'diameter' The diameter of the hemisphere in both x and y
directions. Default 2.
'xwidth' The diameter of the hemisphere in the x direction.
Default 2.
'ywidth' The diameter of the hemisphere in the y direction.
Default 2.
'divisions' The number of divisions around the circumference.
Default 20.
'rings' The number of circular rings of triangles to divide
it into. Default is floor(divisions/6).
Example:
m = leaf_hemisphere( [], 'radius', 2, 'divisions', 15, 'rings', 3 );
Equivalent GUI operation: selecting "Hemisphere" on the pulldown menu on
the "Mesh editor" panel, and clicking the "Generate mesh" button. The
radius and the number of rings are specified in the text boxes with
those labels.
Topics: Mesh creation.
leaf_icosahedron.m
m = leaf_icosahedron( m, ... )
Create a new icosahedral mesh.
Arguments:
M is either empty or an existing mesh. If it is empty, then an
entirely new mesh is created, with the default set of morphogens
If M is an existing mesh, then its geometry is replaced by the new
mesh. It retains the same set of morphogens (all set to zero
everywhere on the new mesh), interaction function, and all other
properties not depending on the specific geometry of the mesh.
Options:
'radius' The radius of the icosahedron. Default 1.
Example:
m = leaf_circle( [], 'radius', 2, 'rings', 4 );
Equivalent GUI operation: selecting "Circle" or "Hemisphere" on the
pulldown menu on the "Mesh editor" panel, and clicking the "Generate
mesh" button.
Topics: Mesh creation.
leaf_iterate.m
[m,ok] = leaf_iterate( m, numsteps, ... )
Run the given number of iterations of the growth process.
In each iteration, the following things happen:
* Strains are set up in the leaf according to the effects of the
morphogens at each point causing the material to grow.
* The elasticity problem is solved to produce a new shape for the
leaf.
* Morphogens which have a nonzero diffusion coefficient are allowed
to diffuse through the mesh.
* If dilution by growth is enabled, the amount of every morphogen
is diluted at each point according to how much that part of the
leaf grew.
* A user-supplied routine is invoked to model local interactions
between the morphogens.
* The layer of biological cells is updated.
* If requested by the options, the mesh is plotted after each
iteration.
Results:
ok: True if there was no problem (e.g. invalid arguments, a user
interrupt, or an error in the interaction function). False if there
was.
Arguments:
numsteps: The number of iterations to perform. If this is zero, the
computation will continue indefinitely or until terminated by the
'until' or 'targetarea' options. The default is 1.
Options:
'until' Run the simulation until this time has been reached or
exceeded. A value of zero disables this option.
'targetarea' Run the simulation until the area of the canvas is at
least this number times the initial area. A value of
zero disables this option.
'plot' An integer n. The mesh will be plotted after every n
iterations. 0 means do not plot the mesh at all; -1 means plot
the mesh only after all the iterations have been completed.
The default value is 1.
Example:
m = leaf_iterate( m, 20, 'plot', 4 );
Equivalent GUI operation: clicking one of the following buttons in the
"Simulation" panel: "Run" (do a specified number of steps), "Step" (do
one step), or "Run to..." (run until the area has increased by a
specified factor).
Topics: Simulation.
leaf_light.m
m = leaf_light( m, on )
Turn the scene light on or off.
Arguments:
on: boolean, true if the light is to be on.
Topics: Plotting.
leaf_load.m
m = leaf_load( m, filename, ... )
Load a mesh from a file. If no filename is given, a dialog will be
opened to choose one.
The expected format depends on the extension of the filename:
.MAT The leaf is contained in the file as a Matlab object called
m.
.M The file contains Matlab commands to create or modify a
leaf. These commands will be executed.
.OBJ Contains only nodes and triangles, in OBJ format. All
other properties of the mesh will be set to their default
values.
If no filename is given, a dialog will be opened to choose one.
If the filename consists of just an extension (including the initial
"."), a dialog will be opened showing only files with that extension.
All of these formats can be generated by leaf_save.
In the case of .MAT and .OBJ files, the existing leaf will be
discarded. A .M file will discard the current leaf only if it contains
a command to create a new leaf; otherwise, it will apply its commands
to the current leaf.
Equivalent GUI operation: the "Load..." button.
Topics: Files, Mesh editing.
leaf_loadgrowth.m
m = leaf_loadgrowth( m, filename ) Load growth data for the leaf from an OBJ or MAT file. If no filename is given, one will be asked for. This assumes the mesh is in growth/anisotropy mode. Equivalent GUI operation: the "Load Growth..." button on the "Morphogens" panel. Topics: Files, Mesh editing.
leaf_loadmodel.m
[m,ok] = leaf_loadmodel( m, modelname, projectdir, ... )
Load a model. If no model name is given or the model name is empty, a
dialog will be opened to choose one. The model will be looked for in
projectdir, if given, otherwise the project directory of m, if any,
otherwise the current directory. The argument m can be empty; in fact,
this will be the usual case.
If the model is successfully loaded, the new model is returned in M and
the (optional) return value OK is set to TRUE. Otherwise M is left
unchanged and OK is set to FALSE.
Options:
rewrite: Normally, when a model is loaded, its interaction
function (if there is one) is read, parsed, and
rewritten. This is because it may have been created with
an older version of GFtbox. Specifying the rewrite
option as false prevents this from being done. This may
be necessary when running several simulations
concurrently on a parallel machine, all using the same
project. Note that when rewrite is true (the default),
the interaction function will not actually be rewritten
until the first time it is called, or any morphogen is
added, deleted, or renamed, or the user requests a
rewrite.
copyname, copydir:
If either of these is given, a new copy of the project
will be made and saved with the specified project name
and parent folder. The original project folder will be
unmodified. If one of these options is given, the other
can be omitted or set to the empty string, in which
case it defaults to the original project name or project
folder respectively. If the value of copyname is '?',
then the user will be prompted to select or create a
project folder. In this case, copydir will be the folder
at which the select-folder dialog starts. If both
options are empty, this is equivalent to omitting both of
them (the default). If copydir and copyname are the same
as modelname and projectdir, a warning will be given, and
the copy options ignored.
interactive:
A boolean value. If true, situations such as missing
files will be reported by dialogs; if false, no dialogs
will be presented. In both cases a message will be
written to the console.
If for any reason the model cannot be saved, a warning will be output,
the loaded model will be discarded, and the empty list returned.
Equivalent GUI operation: the "Load model..." button, or the items on
the Projects menu. The items on the Motifs menu use copyname and
copydir to force the "motif" projects to be opened as copies in the
user's default project directory.
Examples:
m = leaf_loadmodel( [], 'flower7', 'C:\MyProjects\flowers', ...
'copyname', 'flower8', ...
'copydir', 'C:\MyProjects\flowers' );
This loads a model from the folder 'C:\MyProjects\flowers\flower7',
and saves it into a new project folder 'C:\MyProjects\flowers\flower8'.
Since the value of copydir is the same as the projectdir argument,
the copydir option could have been omitted.
Topics: Project management.
leaf_lobes.m
m = leaf_lobes( m, ... )
Create a new mesh in the form of one or more lobes joined together in a
row. A lobe is a semicircle on top of a rectangle.
Arguments:
M is either empty or an existing mesh. If it is empty, then an
entirely new mesh is created, with the default set of morphogens
If M is an existing mesh, then its geometry is replaced by the new
mesh. It retains the same set of morphogens (all set to zero
everywhere on the new mesh), interaction function, and all other
properties not depending on the specific geometry of the mesh.
Options:
'radius' The radius of the semicircle. Default 1.
'rings' The number of circular rings of triangles to divide
it into. Default 4.
'height' The height of the rectangle, as a multiple of the
semicircle's diameter. Default 0.7.
'strips' The number of strips of triangles to divide the
rectangular part into. If 0 (the default), this will
be calculated from the height so as to make the
triangles similar in size to those in the lobes.
'lobes' The number of lobes. The default is 1.
'base' Half the number of divisions along the base of a
lobe. Defaults to rings.
'cylinder' The series of lobes is to behave as if wrapped
round a cylinder and the two ends stitched
together. This is implemented by constraining the
nodes on the outer edges in such a way that the
outer edges remain parallel to the y axis.
Example:
m = leaf_lobes( 'radius', 2, 'rings', 4, 'lobes', 3, 'base', 2 );
See also: LEAF_CIRCLE, LEAF_CYLINDER, LEAF_LUNE, LEAF_ONECELL,
LEAF_RECTANGLE.
Equivalent GUI operation: selecting "Lobes" in the pulldown menu in the
"Mesh editor" panel and clicking the "Generate mesh" button.
Topics: Mesh creation.
leaf_locate_vertex.m
m = leaf_locate_vertex( m, ... )
Ensure that certain degrees of freedom of a single node remain
constant. This is ensured by translating the mesh so as to restore the
values of the specified coordinates, after each iteration.
Options:
'vertex' The vertex to be held stationary. If the empty list is
supplied, no vertex will be fixed and dfs is ignored.
'dfs' The degrees of freedom to be held stationary. This is a
string made of the letters 'x', 'y', and 'z'. This
defaults to 'xyz', i.e. fix the vertex completely.
Each degree of freedom not in dfs will be unconstrained.
It is only possible to fix a vertex in directions parallel to the
axes.
Equivalent GUI operation: clicking on the mesh while the Mesh editor
panel is selected and 'Locate' is selected in the Fix/Delete menu. The
'x', 'y', and 'z' checkboxes specify which degrees of freedom to
constrain or unconstrain.
Topics: Mesh editing.
leaf_lune.m
m = leaf_lune( m, ... )
NOT IMPLEMENTED.
Create a new mesh in the shape of a stereotypical leaf, oval with
pointed ends.
Arguments:
M is either empty or an existing mesh. If it is empty, then an
entirely new mesh is created, with the default set of morphogens
If M is an existing mesh, then its geometry is replaced by the new
mesh. It retains the same set of morphogens (all set to zero
everywhere on the new mesh), interaction function, and all other
properties not depending on the specific geometry of the mesh.
Options:
'xwidth' The diameter in the X dimension. Default 3.
'ywidth' The diameter in the Y dimension. Default 2.
'xdivs' The number of segments to divide it into along the
X axis. Default 8.
Example:
m = leaf_lune( [], 'xwidth', 3, 'ywidth', 2, 'xdivs', 8 );
See also: LEAF_CIRCLE, LEAF_CYLINDER, LEAF_ONECELL,
LEAF_RECTANGLE, LEAF_SEMICIRCLE, LEAF_LOBES.
Equivalent GUI operation: selecting "Leaf" in the pulldown menu in the
"Mesh editor" panel and clicking the "Generate mesh" button.
Topics: UNIMPLEMENTED, Mesh creation.
leaf_makesecondlayer.m
m = leaf_makesecondlayer( m, ... )
Make a new Bio-A layer, either adding to or discarding any existing one.
Options:
mode: One of the following strings:
'full': cover the entire surface with a continuous sheet of
cells. There will be one cell per FE cell plus one cell
per FE vertex.
'grid': cover the entire surface with a continuous sheet of
square cells.
'voronoi': cover the entire surface with a continuous sheet of
cells. The 'numcells' option specifies how many. This is
only valid for flat or nearly flat meshes.
'single': make a single second layer cell in a random position.
'few': make a specified number of second layer cells, each in a
different randomly chosen FEM cell.
'each': make one second layer cell within each FEM cell.
absdiam: Not valid for mode=full. In all other cases, this is a real
number, being the diameter of a single cell.
absarea: Not valid for mode=full. In all other cases, this is a real
number, being the area of a single cell.
reldiam: Not valid for mode=full. In all other cases, this is a real
number, being the diameter of a single cell as a proportion
of the diameter of the current mesh (estimated as the
square root of the mesh area).
relarea: Not valid for mode=full. In all other cases, this is a real
number, being the area of a single cell as a proportion
of the area of the current mesh.
relinitarea: Not valid for mode=full. In all other cases, this is a real
number, being the area of a single cell as a proportion
of the area of the initial mesh.
abssize: OBSOLETE, REMOVED. Use 'absdiam' instead.
relsize: OBSOLETE, REMOVED. Use 'reldiam' instead.
relinitarea: OBSOLETE, REMOVED.
relFEsize: OBSOLETE, REMOVED.
axisratio: The ratio of major to minor axis of the cells. If
this is not 1, the major axis will be parallel to the
polariser gradient, if any; if there is no polariser
gradient, or at the cell location it is beneath the
threshold for it to be effective, the cell will be
created circular. The default value is 1.
numcells: Valid only for mode='voronoi', mode='each', or
mode='few'. An integer specifying the number of cells to
create.
sides: Each cell is created as a regular polygon having this many
sides. The default is 12, but if you are using a very
large number of cells, rendering will be significantly
faster if you use fewer sides.
refinement: NOT USED. IGNORE.
add: Boolean. If true, existing cells are retained and new
cells are added to them. If false, any existing biological
layer is discarded. If 'mode' is 'full' or 'voronoi', the
old layer is always discarded, ignoring the 'add' argument.
allowoverlap: Boolean. If true, cells are allowed to overlap each
other. If false, cells will not overlap each other. You
may as a result end up with fewer cells that you asked for.
colors: The colour of the new cells, as an RGB value.
colorvariation: The amount of variation in the colour of the new
cells. Each component of the colour value will be randomly
chosen within this ratio of the value set by the 'color'
argument. That is, a value of 0.1 will set each component
to between 0.9 and 1.1 times the corresponding component of
the specified colour. (The variation is actually done in
HSV rather than RGB space, but the difference is slight.)
probperFE: For 'each' mode, this specifies for each FE the
probability per unit area for creating a cell there.
Any value less than 0 is equivalent
to 0. The values will be scaled so as to add to 1.
probpervx: Like probperFE, but the values are given per vertex.
Alternatively, the value can be a morphogen name or index,
in which case the values of that morphogen at each vertex
will be used.
The options 'probperFE', and 'probpervx' are mutually
exclusive.
vertexdata: Instead of generating the cells according to one of
the methods described above, take this N*3 array to be the
positions of all of the cell vertexes.
celldata: To be used with vertexdata. This is a cell array of
integer arrays, each integer array specifying the vertexes
of one cell in order around the cell.
vertexindexing: This is either 1 or 0. If celldata is provided, then
this specifies whether the indexes in celldata are 1-based
or 0-based. 1-based is the default, since that is Matlab's
convention for all indexing of arrays, but external data
may often be zero-based. If vertexindexing is not supplied
or is empty, then if zero occurs anywhere in celldata, it
will be assumed to be zero-based, otherwise 1-based.
If either 'vertexdata' or 'celldata' is supplied, the other must
also be, and all other options that specify the manner of creating
cells will be ignored.
At most one of ABSDIAM, ABSAREA, RELDIAM, and RELAREA should be given.
Equivalent GUI operation: clicking the "Make cells" button on the Bio-A
panel. This is equivalent to m = leaf_makesecondlayer(m,'mode','full').
Topics: Bio layer.
leaf_mgen_absorption.m
m = leaf_mgen_absorption( m, morphogen, absorption )
Set the rate at which a specified morphogen is absorbed.
Arguments:
morphogen: The name or index of a morphogen.
absorption: The rate of decay of the morphogen. A value of 1 means that
the morphogen decays by 1% every 0.01 seconds.
Values can be set for multiple morphogens by listing morphogens names
and absorptions alternately. Where more than one morphogen is to be
given the same absorption, an array of morphogen indexes or a cell
array of morphogen names can be given.
Examples:
m = leaf_mgen_absorption( m, {'abc','def'}, 0.5 );
Equivalent GUI operation: setting the value in the "Absorption"
text box in the "Morphogens" panel.
Topics: Morphogens.
leaf_mgen_color.m
m = leaf_mgen_color( m, ... )
Associate colours with morphogens.
Options:
'morphogen': The morphogens to attach colours to. This can be a
single morphogen name, an array of morphogen
indexes, or a cell array or morphogen names.
'color': Either a single letter, as used in various Matlab
plotting functions, a single RGB triple (row or
column), or a 3*N array of colours, one for each of
the N morphogens specified by the morphogen
argument. If you give an N*3 array instead it will
transpose it for you, unless N=3, in which case you
have to get it right yourself. The colours are the
columns, not the rows.
Instead of a single letter, it can be a pair of
letters, in which case the first is used for the
color of positive values and the second for negative
values. If numerical values are supplied, color can
be an A*B*2 array, in which color(:,:,1) is used as
described above for the positive values, and
color(:,:,2) is used for the negative values.
If colours are not provided for negative values,
colours opposite to those supplied for positive
values will automatically be used.
Topics: Morphogens, Plotting.
leaf_mgen_conductivity.m
m = leaf_mgen_conductivity( m, morphogen, conductivity, ... )
Set the rate at which a specified morphogen diffuses through the leaf.
Arguments:
morphogen: The name or index of a morphogen.
conductivity: The diffusion constant for the morphogen, in units of
length^2/time.
Values can be set for multiple morphogens by listing morphogen names
and conductivities alternately. Where more than one morphogen is to be
given the same conductivity, an array of morphogen indexes or a cell
array of morphogen names can be given.
Example:
m = leaf_mgen_conductivity( m, 'kapar', 0.05, {'foo','bar'}, 0.3, [10 12 13], 0.02 );
This will set the diffusion constant for KAPAR to 0.05, those for FOO
and BAR to 0.3, and those for morphogens 10, 12, and 13 to 0.02.
Equivalent GUI operation: setting the value in the "Diffusion"
text box in the "Morphogens" panel.
Topics: Morphogens.
leaf_mgen_const.m
m = leaf_mgen_const( m, morphogen, amount )
Add a constant amount to the value of a specified morphogen everywhere.
Arguments:
1: The name or index of a morphogen. Currently, if
the name is provided, it must be one of the following:
'growth', 'polariser', 'anisotropy',
'bend', 'bendpolariser', 'bendanisotropy'.
These are respectively equivalent to the indexes 1 to 6 (which
are the only valid indexes). There is no default for this option.
2: The amount of morphogen to add to every node. A value
of 1 will give moderate growth or bend, and a maximum growth or
bend anisotropy. A constant field of growth or bend polarizer
has no effect: polarising morphogen has an effect only through
its gradient.
Examples:
m = leaf_mgen_const( m, 'growth', 1 );
m = leaf_mgen_const( m, 3, 0.8 );
See also: LEAF_MGEN_RADIAL.
Equivalent GUI operation: clicking the "Add const" button in the
"Morphogens" panel. The amount is specified by the "Amount slider and
test item.
Topics: Morphogens.
leaf_mgen_dilution.m
m = leaf_mgen_dilution( m, morphogen, enable )
Set the rate at which a specified morphogen is absorbed.
Arguments:
1: The name or index of a morphogen.
2: A boolean specifying whether to enable dilution by growth
Examples:
m = leaf_mgen_dilution( m, 'growth', 1 );
Equivalent GUI operation: setting the "Dilution" checkbox in the
"Morphogens" panel.
Topics: Morphogens.
leaf_mgen_edge.m
m = leaf_mgen_edge( m, morphogen, amount, ... )
Set the value of a specified morphogen to a given amount everywhere on
the edge of the leaf.
Arguments:
1: The name or index of a morphogen.
2: The maximum amount of morphogen to add to every node.
Examples:
m = leaf_mgen_edge( m, 'growth', 1 );
See also: leaf_mgen_const.
Equivalent GUI operation: clicking the "Add edge" button in the
"Morphogens" panel. The amount is specified by the "Amount slider and
test item.
Topics: Morphogens.
leaf_mgen_get_conductivity.m
c = leaf_mgen_get_conductivity( m, morphogens )
Return the rate at which a specified morphogen diffuses through the leaf.
Arguments:
morphogens: The name or index of a morphogen, or a cell array or
numeric array of morphogens.
The result is a struct array with one element for each morphogen
requested. The fields of each struct will be Dpar and Dper, each of
which will be either a single number or an array or numbers, one per
finite element. Dper may also be empty. These are the diffusion
constants of the morphogen parallel or perpendicular to the polariser
gradient. A single number imples a constant value over the whole mesh.
An empty array for Dper implies that it is everywhere identical to
Dpar. An empty array for Dpar implies that it is everywhere zero.
Example:
c = leaf_mgen_get_conductivity( m, {'foo','bar'} );
c will be a struct array of length two.
Topics: Morphogens.
leaf_mgen_linear.m
m = leaf_mgen_linear( m, morphogen, amount, ... )
Set the value of a specified morphogen to a linear gradient.
Arguments:
1: The name or index of a morphogen.
2: The maximum amount of morphogen to add to every node.
Options:
'direction' Either a single number (the angle in degrees
between the gradient vector and the X axis, the
gradient vector lying in the XY plane; or a triple
of numbers, being a vector in the direction of the
gradient. The length of the vector does not
matter. Default is a gradient parallel to the
positive X axis.
Examples:
m = leaf_mgen_linear( m, 'growth', 1, 'direction', 0 );
See also: leaf_mgen_const.
Equivalent GUI operation: clicking the "Add linear" button in the
"Morphogens" panel. The amount is specified by the "Amount" slider and
test item. Direction is specified in degrees by the "Direction" text
box.
Topics: Morphogens.
leaf_mgen_modulate.m
m = leaf_mgen_modulate( m, ... )
Set the switch and mutant levels of a morphogen.
Options:
morphogen: The name or index of a morphogen. If omitted, the
properties are set for every morphogen.
switch, mutant: Value by which the morphogen is multiplied to give its
effective level.
If either switch or mutant is omitted its current value is
left unchanged.
The effective value of a morphogen is the product of the actual
morphogen amount, the switch value, and the mutant value. So
mutant and switch have the same effect; the difference is
primarily in how they are intended to be used. Mutant value is
settable in the Morphopgens panel of the GUI and is intended to have a
constant value for each morphogen throughout a run. There is also a
checkbox in the GUI to turn all mutations on and off. Switch value has
no GUI interface, and is intended to be changed in the interaction
function. The switch values are always effective.
The initial values for switch and mutant in a newly created leaf are 1.
Examples:
m = leaf_mgen_modulate( m, 'morphogen', 'div', ...
'switch', 0.2, ...
'mutant', 0.5 );
Sets the switch level of 'div' morphogen to 0.2 and the mutant
level to 0.5. The effective level will then be 0.1 times the
actual morphogen.
Topics: Morphogens.
leaf_mgen_plotpriority.m
m = leaf_mgen_plotpriority( m, morphogen, priority, thresholds )
Set the plotting priorities of specified morphogens. In multi-plot
mode, the priorities determine whether morphogens present at the same
place are mixed, or one overlies the other.
The default priority for all morphogens is 0. When multiple morphogens
of differing priorities are plotted together, the procedure for
determining the colour of a vertex is as follows:
1. For each group of morphogens of the same priority, the colors for
those morphogens are mixed. This gives one coloring of the whole
mesh for each priority group.
2. At each vertex of the mesh, the chosen colour is taken from the
color map of highest priority for which at least one of the
associated morphogens is above its plotting threshold at that
vertex.
If the canvas has a background colour, it is considered to have
the same priority as the morphogen with least priority, or zero,
whichever is less.
Arguments:
1: The name or index of a morphogen, or a cell array of names or an
array of indexes
2: The priorities of the listed morphogens. If a single value is given
it is applied to all of them. If multiple values are given there
must be exactly as many of them as in the list of morphogens.
Priorities can be any numerical value.
3: (Optional) Thresholds for each of the listed morphogens. In
multi-plotting mode, a morphogen whose value is less than or equal
to its threshold will be treated as zero for the purpose of masking
lower-priority morphogens. The default threshold is zero.
Example:
m = leaf_mgen_plotpriority( m, ...
{'id_sink','id_source','id_ridge'}, [1 1 2], [0,0,0.1] );
This gives priority 2 to the morphogen id_ridge, 1 to id_sink and
id_source, and leaves all others with the default priority of zero. If
all morphogens are being plotted together, then where id_ridge is
greater than 0.1, its colour will be plotted. Elsewhere, where id_sink or
id_source is greater than zero, their colours will be mixed and plotted.
Everywhere else, the other morphogen colours will be mixed together.
This will have the effect that id_source will overlie id_sink, and both
will overlie all other morphogens.
Equivalent GUI operation: None.
Topics: Plotting.
leaf_mgen_radial.m
m = leaf_mgen_radial( m, morphogen, amount, ... )
Add to the value of a specified morphogen an amount depending on the
distance from an origin point.
Arguments:
1: The name or index of a morphogen.
2: The maximum amount of morphogen to add to every node.
Options:
'x', 'y', 'z' The X, Y, and Z coordinates of the centre of the
distribution, relative to the centre of the mesh.
Default is (0,0,0).
Examples:
m = leaf_mgen_radial( m, 'growth', 1, 'x', 0, 'y', 0, 'z', 0 );
m = leaf_mgen_radial( m, 'g_anisotropy', 0.8 );
See also: leaf_mgen_const.
Equivalent GUI operation: clicking the "Add radial" button in the
"Morphogens" panel. The amount is specified by the "Amount slider and
test item. x, y, and z are specified in the text boxes of those names.
Topics: Morphogens.
leaf_mgen_random.m
m = leaf_mgen_random( m, morphogen, amount, ... )
Add a random amount of a specified morphogen at each mesh point.
Arguments:
1: The name or index of a morphogen.
2: The maximum amount of morphogen to add to every node.
Options:
'smooth' An integer specifying the smoothness of the
distribution. 0 means no smoothing: the value at
each node is independent of each of its neighbours.
Greater values imply more smoothness. Default is
2.
Examples:
m = leaf_mgen_random( m, 'growth', 1 );
m = leaf_mgen_random( m, 'g_anisotropy', 0.8 );
See also: LEAF_MGEN_CONST.
Equivalent GUI operation: clicking the "Add random" button in the
"Morphogens" panel. The amount is specified by the "Amount slider and
test item.
Topics: Morphogens.
leaf_mgen_reset.m
m = leaf_mgen_reset( m )
Set the values of all morphogens, and their production rates and clamp
settings, to zero everywhere.
Example:
m = leaf_mgen_reset( m );
Equivalent GUI operation: clicking the "Set zero all" button in the
"Morphogens" panel.
Topics: Morphogens.
leaf_mgen_scale.m
m = leaf_mgen_scale( m, morphogen, scalefactor )
Scale the value of a given morphogen by a given amount.
Arguments:
1: The name or index of a morphogen.
2: The scale factor.
Examples:
m = leaf_mgen_scale( m, 'bpar', -1 );
See also: leaf_mgen_const.
Equivalent GUI operation: clicking the "Invert" button in the
"Morphogens" panel will scale the current morphogen by -1. There is not
yet a user interface for a general scale factor.
Topics: Morphogens.
leaf_mgen_zero.m
m = leaf_mgen_zero( m, morphogen )
Set the value of a specified morphogen to zero everywhere.
Arguments:
1: The name or index of a morphogen.
Examples:
m = leaf_mgen_zero( m, 'growth' );
See also: LEAF_MGEN_CONST.
Equivalent GUI operation: clicking the "Set zero" button in the
"Morphogens" panel.
Topics: Morphogens.
leaf_mgeninterpolation.m
m = leaf_mgeninterpolation( m, ... )
Set the interpolation mode of morphogens of m. When an edge of the
mesh is split, this determines how the morphogen values at the new
vertex are determined from the values at either end of the edge.
Options:
'morphogen' This can be a morphogen name or index, a cell array of
morphogen names and indexes, or a vector of indexes.
'interpolation' Either 'min', 'max', or 'average'. If 'min', the new
values are the minimum of the old values, if 'max' the
maximum, and if 'average' the average.
GUI equivalent: the radio buttons in the "On split" subpanel of the
"Morphogens" panel. These set the interpolation mode for the current
morphogen. As of the version of 2008 Sep 03, new meshes are created
with the interpolation mode for all morphogens set to 'min'.
Previously the default mode was 'average'.
Example:
m = leaf_mgeninterpolation( m, ...
'morphogen', 1:size(m.morphogens,2), ...
'interpolation', 'average' );
This sets the interpolation mode for every morphogen to 'average'.
Topics: Morphogens.
leaf_morphogen_midpoint.m
function [m,target_p,TargetMorphArea]=morphogen_midpoint(m,varargin)
uses one or two gradient of diffusing morphogen to define
a region in TARGETMORPH.
initially the region is set to the value 1
However, once it is stable it is set to 2 and
the interaction function should stop trying to change the midpoint.
It also defines a region of all vertices > threshold used
to define TARGETMORPH (i.e. all below the midpoint)
usage
%intersection of two opposing gradients and view clustering
[circ2_p,tube_p]=leaf_morphogen_midpoint('DIFF1MORPH',p1_l,...
'DIFF2MORPH',p2_l,'TARGETMORPH',circ2_p,'LABEL','CIRC2','VERBOSE',true);
%intersection of two opposing gradients
[circ2_p,tube_p]=leaf_morphogen_midpoint('DIFF1MORPH',p1_l,...
'DIFF2MORPH',p2_l,'TARGETMORPH',circ2_p);
%find lowpoint in a U shaped diffusing morphogen
[mid_p]=leaf_morphogen_midpoint('DIFF1MORPH',midd_p,'TARGETMORPH',mid_
p);
Topics: Morphogens.
leaf_morphogen_pulse.m
[gm_l,gm_p]=leaf_morphogen_pulse(m,varargin) Topics: Morphogens.
leaf_morphogen_switch.m
function gm_l=leaf_morphogen_switch(m,varargin)
usage
Here the default on and off values of 0 and 1 are used
[m,tube_l]=leaf_morphogen_switch(m,...
'StartTime',OnsetOfTubeGrowth,'EndTime',FinishTubeGrowth,...
'Morphogen_l','tube','RealTime',realtime);
Alternatively, these can be specified
[m,basemid_l]=leaf_morphogen_switch(m,...
'StartTime',OnsetOfTubeGrowth,'EndTime',FinishTubeGrowth,...
'Morphogen_l','basemid','RealTime',realtime,...
'OnValue',1.0,'OffValue',0.0);
Topics: Morphogens.
leaf_movie.m
m = leaf_movie( m, ... )
Start or stop recording a movie.
Any movie currently being recorded will be closed.
If the first optional argument is 0, no new movie is started.
Otherwise, the arguments may contain the following option-value pairs:
FILENAME The name of the movie file to be opened. If this is not
given, and m.globalProps.autonamemovie is true, then a name
will be generated automatically, guaranteed to be different
from the name of any existing movie file. Otherwise, a file
selection dialog is opened.
MODE (NOT IMPLEMENTED) This is one of 'screen', 'file', or 'fig'.
'screen' will capture the movie frames from the figure
as drawn on the screen, using avifile().
'file' will use print() to save the
figure to a file, then load the file and add it to the
movie. This allows arbitrarily high resolution movies to
be made, not limited to the size drawn on the screen.
'fig' will save each frame as a MATLAB .fig file
and will not generate a movie file. The figures can later
be assembled into a movie file by running the command
fig2movie. The reason for this option is that when
running in an environment with no graphics, I have been
unable to find a way of creating images from figures.
FPS, COMPRESSION, QUALITY, KEYFRAME, COLORMAP, VIDEONAME: These options
are passed directly to the Matlab function AVIFILE. LEAF_MOVIE provides
defaults for some of these:
FPS 15
COMPRESSION 'None'
QUALITY 100
KEYFRAME 5
Equivalent GUI operation: clicking the "Record movie..." button.
See also AVIFILE.
Topics: Movies/Images.
leaf_multiplylayers.m
[m,ok] = leaf_multiplylayers( m, varargin )
Replace a single-layer mesh by a mesh of multiple layers glued together.
This should not be called if the mesh is already a multple-layer mesh,
or already contains any vertexes that are stitched together.
Options:
layers: The number of layers to make. The default value is 2.
force: Normally this procedure will not act on a mesh that already
contains constraints that force some nodes to have equal
displacements. If 'force' is true then any such constraints will
be deleted and the mesh will be multiplied. The default is false.
leaf_onecell.m
m = leaf_onecell( m, ... )
Create a new leaf consisting of a single triangular cell.
Arguments:
M is either empty or an existing mesh. If it is empty, then an
entirely new mesh is created, with the default set of morphogens
If M is an existing mesh, then its geometry is replaced by the new
mesh. It retains the same set of morphogens (all set to zero
everywhere on the new mesh), interaction function, and all other
properties not depending on the specific geometry of the mesh.
Options:
'xwidth' The diameter in the X dimension. Default 1.
'ywidth' The diameter in the Y dimension. Default 1.
Example:
m = leaf_onecell( [], 'xwidth', 1, 'ywidth', 1 );
See also: LEAF_CIRCLE, LEAF_CYLINDER, LEAF_LUNE,
LEAF_RECTANGLE, LEAF_SEMICIRCLE.
Equivalent GUI operation: selecting "One cell" in the pulldown menu in
the "Mesh editor" panel and clicking the "Generate mesh" button.
Topics: Mesh creation.
leaf_paintpatch.m
m = leaf_paintpatch( m, cells, morphogen, amount ) Apply the given amount of the given morphogen to every vertex of each of the cells. The cells are identified numerically; the numbers are not user-accessible. This command is therefore not easily used manually; it is generated when the user clicks on a cell in the GUI. Arguments: 1: A list of the cells to apply the morphogen to. 2: The morphogen name or index. 3: The amount of morphogen to apply. Equivalent GUI operation: clicking on every vertex of the cell to be painted, with the "Current mgen" item selected in the "Mouse mode" menu. The morphogen to apply is specified in the "Displayed m'gen" menu in the "Morphogens" panel. Topics: Morphogens.
leaf_paintvertex.m
m = leaf_paintvertex( m, morphogen, ... )
Apply the given amount of the given morphogen to all of the given
vertexes. The vertexes are identified numerically; the numbers are
not user-accessible. This command is therefore not easily used
manually; it is generated when the user clicks on a vertex in the GUI.
Arguments:
1: The morphogen name or index.
Options:
'vertex' The vertexes to apply morphogen to.
'amount' The amount of morphogen to apply. This can be either a
single value to be applied to every specified vertex,
or a list of values of the same length as the list of
vertexes, to be applied to them respectively.
'mode' Either 'set' or 'add'. 'set sets the vertex to the
given value, 'add' adds the given value to the current
value.
Equivalent GUI operation: clicking on the mesh when the "Morphogens"
panel is selected. This always operates in 'add' mode. The morphogen
to apply is specified in the "Displayed m'gen" menu in the "Morphogens"
panel. Shift-clicking or middle-clicking will subtract the morphogen
instead of adding it.
Topics: Morphogens.
leaf_perturbz.m
m = leaf_perturbz( m, z, ... )
Add a random perturbation to the Z coordinate of every node.
Arguments:
A number z, the amplitude of the random displacement. The
displacements will be randomly chosen from the interval -z/2 ...
z/2.
Options:
'absolute': A boolean. If true, then the displacements will be
interpreted as alsolute distances. If false (the
default), they will be interpreted as amounts
relative to the thickness at each point.
Example:
m = leaf_perturbz( m, 0.5, 'absolute', true )
Equivalent GUI operation: the "Random Z" button on the "Mesh editor"
panel. The amount of random deformation is specified by the value in
the upper of the two text boxes to the right of the button. In the
GUI, 'absolute' is always assumed to be false.
Topics: Mesh editing.
leaf_plot.m
m = leaf_plot( m, ... ) Plot the leaf. There are many options. leaf_plot stores all of the plotting options in the mesh, so that a subsequent call to leaf_plot with only the mesh as an argument will plot the same thing. Equivalent GUI operation: none. The leaf is plotted automatically. Various options may be set in the "Plot options" panel, and the scroll bars on the picture change the orientation. See also: leaf_plotoptions. Topics: Plotting.
leaf_plotoptions.m
[m,plotinfo] = leaf_plotoptions( m, ... ) Set the plotting options. There are many options. leaf_plotoptions resolves all inconsistencies among the options given and the options already present in m, and stores the resulting set of options into m. leaf_plot2 calls leaf_plotoptions2, computes the data to be plotted, and does the plotting. The PLOTINFO output argument is for internal use and should be ignored. Equivalent GUI operation: Various options may be individually set in the GUI, especially the "Plot options" panel. See also: leaf_plot. Topics: Plotting.
leaf_plotview.m
m = leaf_plotview( m, ... )
Set the view parameters.
There are two sets of parameters with which the view can be described:
1. The parameters that Matlab itself uses:
CameraViewAngle
CameraTarget
CameraPosition
CameraUpVector
2. An alternative set that is sometimes more convenient:
fov (field of view)
azimuth
elevation
roll
pan (two components)
targetdistance (the distance that CameraTarget is behind the plane
perpendicular to the view direction through the origin of
coordinates)
camdistance (the distance that CameraTarget is in front of the
plane perpendicular to the view direction through the origin
of coordinates)
Both sets of parameters are maintained in the mesh structure.
For example, to set an overhead view:
m = leaf_plotview( m, 'azimuth', 0, 'elevation', 90, 'roll', 0 );
Topics: Plotting.
leaf_profile_monitor.m
function m=leaf_profile_monitor(m,realtime,RegionLabels,Morphogens,start_figno)
monitor morphogen levels at a set of vertices
m, mesh
RegionLabels, vertices to be monitored as designated by cell array of strings, i.e. region labels
Morphogens, cell array of strings, i.e. uppercase morphogen names to
be monitored. There should be one RegionLabels string for each
Morphogens string
Vertlabels, if true then display vertex numbers in each regionlabel on
the mesh default false
start_figno, default figure 1 (Must open a fig even if just monitoring to file)
MonData, optional output of data structure
For example:
pathname: 'D:\ab\Matlab stuff\Growth models\GPT_MeasureGrowth_20121203\snapshots'
filename: 'monitor--03-Dec-2012-17-39-16.xls'
CurrentExcelColumn: 5
vertex_set: {[5x1 double]}
index: {[1]}
list_order: {[1 2 3 4 5]}
regionlabel: {'ID_MID'}
ListOK: {[1]}
Results: [1x1 struct]
Results.REGN: {'ID_MID'}
Results.XYZ: {[5x3 double]}
Results.XYZA: {[5x3 double]}
Results.XYZB: {[5x3 double]}
Results.X: {[5 5 5 5 5]}
Results.Y: {[5x1 double]}
Results.Z: {[]}
Results.D: {[5x1 double]} % distances between vertices
Results.G: {[]}
Results.XYZ_LegendString:
Results.D_LegendString: {' ID_MID: intervals'}
Results.G_LegendString: []
theaxes: [0 1.1410e+03 1.1420e+03]
InitialMaxD: 0.5061
LastD: {[5x1 double]}
e.g.
monitor properties of vertices
m=leaf_profile_monitor(m,... % essential
'REGIONLABELS',{'V_PROFILE1','V_PROFILE2'},... % essential
'MORPHOGENS',{'S_LEFTRIGHT','S_CENTRE'},... % optional (one element per REGIONLABEL)
'VERTLABELS',false,'FigNum',1,'EXCEL',true,'MODELNAME',modelname); % optional (file in snapshots directory')
or if you want to limit the time(s) over which it runs
if realtime>5
m=leaf_profile_monitor(m,... % essential
'REGIONLABELS',{'V_PROFILE1','V_PROFILE2'},... % essential
'MORPHOGENS',{'S_LEFTRIGHT','S_CENTRE'},... % optional (one element per REGIONLABEL)
'VERTLABELS',false,'FigNum',1,'MATFILE',true,'MODELNAME',modelname); % optional (file in snapshots directory')
end
Topics: Simulation.
J. Andrew Bangham, 2011
leaf_purgeproject.m
m = leaf_purgeproject( m )
Purge the project directory of generated files.
The movies directory and its entire contents will be deleted.
The snapshots directory and its entire contents will be deleted.
The runs directory and its entire contents will be deleted.
All stage files will be deleted.
No other files will be affected.
Options:
'recycle' A boolean. If true (the default) then deleted files
are sent to the wastebin. If false, they are
irrevocably deleted immediately.
'confirm' A boolean. If true (the default is false), the user
will be asked to confirm the operation.
leaf_rasterize.m
m = leaf_rasterize( m, ... )
Convert a mesh to a 3D raster scan. The raster is represented as a
series of PNG files, one for each section through the mesh. The raster
scan will be coloured according to the current plot settings for the
mesh.
Options:
filename The pattern of the names of the files to create. This
should contain the substring '%d', which will be
replaced by the index number of each section through
the mesh. The name can be a relative or absolute path
name. If relative, it will be understood as relative
to the 'dirname' argument, if present, otherwise
relative to the project directory's 'meshes'
subdirectory, or if the mesh does not belong to a
project, the current working directory.
dirname The direectory to save the files in. Ignored if the
'filename' argument was an absolute path name.
rastersize A vector of three integers [X Y Z], specifying how many
pixels the raster should be in each direction. The
mesh will be centered in the resulting 3D image, and
will be uniformly scaled so as to fill the space, less
whatever margin is specified.
margin A single integer, a triple [X Y Z], or a sextuple [X1 X2
Y1 Y2 Z1 Z2]. The specified number of pixels will be
left blank on the faces of the raster and the mesh
rendered within the remaining volume.
leaf_recomputestages.m
m = leaf_recomputestages( m, ... )
Recompute a set of stages of the project, starting from the current
state of m. If this is after any of the stages specified, those stages
will not be recomputed.
Options:
'stages' A list of the stages to be recomputed as an array of
numerical times. The actual times of the saved stages
will be the closest possible to those specified, given
the starting time and the time step. If this option is
omitted, it will default to the set of stage times
currently stored in m, which can be set by
leaf_requeststages.
See also: leaf_requeststages
Topics: Simulation.
leaf_record_mesh_frame.m
It is intended that this will add a file copy of m
to a subdirectory of movie
Once RecordMeshes has been turned on either by
using the user interface, 'Movie:Also record meshes'
or by calling this function with arguments
'RECORD','ON' (or turned off with 'RECORD','OFF')
then this function is called from 'leaf_movie' each time a
frame is added to a movie.
The meshes are stored in a directory with a filename that
matches that of the movie.
Topics: Movies/Images.
leaf_rectangle.m
m = leaf_rectangle( m, varargin )
Create a new rectangular mesh.
Arguments:
M is either empty or an existing mesh. If it is empty, then an
entirely new mesh is created, with the default set of morphogens
If M is an existing mesh, then its geometry is replaced by the new
mesh. It retains the same set of morphogens (all set to zero
everywhere on the new mesh), interaction function, and all other
properties not depending on the specific geometry of the mesh.
Options:
'xwidth' The width of the rectangle in the X dimension. Default 2.
'ywidth' The width of the rectangle in the Y dimension. Default 2.
'centre' Where the centre of the rectangle should be.
'xdivs' The number of finite element cells along the X dimension.
Default 8.
'ydivs' The number of finite element cells along the Y dimension.
Default 8.
'base' The number of divisions along the side with minimum Y
value. The default is xdivs.
Example:
m = leaf_rectangle( [], 'xwidth', 2, 'ywidth', 2, 'xdivs', 8,
'ydivs', 8, 'base', 5 )
See also: LEAF_CIRCLE, LEAF_CYLINDER, LEAF_LEAF, LEAF_ONECELL,
LEAF_SEMICIRCLE.
Equivalent GUI operation: selecting "Rectangle" in the pulldown menu in
the "Mesh editor" panel and clicking the "Generate mesh" button.
Topics: Mesh creation.
leaf_rectifyverticals.m
m = leaf_rectifyverticals( m ) Force the lines joining vertexes on opposite surfaces of the mesh to be perpendicular to the mid-surface.
leaf_refineFEM.m
m = leaf_refineFEM( m, amount )
AMOUNT is between 0 and 1. Split that proportion of the edges of the
finite element mesh, in random order.
Example:
m = leaf_refineFEM( m, 0.3 );
Equivalent GUI operation: clicking the "Refine mesh" button in the
"Mesh editor" panel. The scroll bar and text box set the proportion of
edges to be split.
Topics: Mesh editing.
leaf_reload.m
m = leaf_reload( m, stage, varargin )
Reload a leaf from the MAT, OBJ, or PTL file it was last loaded from,
discarding all changes made since then. If there was no such previous
file, the mesh is left unchanged.
Arguments:
stage: If 0 or more, the indicated stage of the mesh, provided
there is a saved state from that stage. If 'reload', the
stage that the mesh was loaded from or was last saved to,
whichever is later. If 'restart', the initial stage of the
mesh. If the indicated stage does not exist a warning is
given and the mesh is left unchanged. The default is
'reload'.
Options:
rewrite: Normally, when a model is loaded, its interaction
function (if there is one) is read, parsed, and
rewritten. This is because it may have been created with
an older version of GFtbox. Specifying the rewrite
option as false prevents this from being done. This may
be necessary when running several simulations
concurrently on a parallel machine, all using the same
project.
Equivalent GUI operations: The "Restart" button is equivalent to
m = leaf_reload( m, 'restart' );
The "Reload" button is equivalent to
m = leaf_reload( m, 'reload' );
or
m = leaf_reload( m );
The items on the "Stages" menu are equivalent to
m = leaf_reload( m, s );
for each valid s. s should be passed as a string. For example, if
the Stages menu has a menu item called 'Time 315.25', that stage
can be loaded with
m = leaf_reload( m, '315.25' );
Topics: Project management.
leaf_rename_mgen.m
m = leaf_rename_mgen( m, oldMgenName, newMgenName, ... )
Rename one or more morphogens. Any number of old name/new name pairs
can be given. The standard morphogens cannot be renamed, and no
morphogen can be renamed to an existing name.
Equivalent GUI operation: clicking the "Rename" button in the
"Morphogens" panel.
See also:
leaf_add_mgen, leaf_delete_mgen
Topics: Morphogens.
leaf_requeststages.m
m = leaf_requeststages( m, ... )
Add a set of stage times to the mesh. None of these will be computed,
but a subsequent call to leaf_recomputestages with no explicit stages
will compute them.
Options:
'stages' A list of numerical stage times. These do not have to
be sorted and may contain duplicates. The list will be
sorted and have duplicates removed anyway.
'mode' If 'replace', the list will replace any stage times
stored in m. If 'add' (the default), they will be
combined with those present.
GUI equivalent: Stages/RequestMore Stages... menu item. This does not
support the 'mode' option and always operates in 'add' mode.
Topics: Simulation, Project management.
leaf_rescale.m
m = leaf_rescale( m, ... )
Rescale a mesh in space and/or time.
Arguments:
M is either empty or an existing mesh. If it is empty, then an
entirely new mesh is created, with the default set of morphogens
If M is an existing mesh, then its geometry is replaced by the new
mesh. It retains the same set of morphogens (all set to zero
everywhere on the new mesh), interaction function, and all other
properties not depending on the specific geometry of the mesh.
Options:
'spaceunitname' The name of the new unit of distance.
'spaceunitvalue' The number of old units that the new unit is
equal to.
'timeunitname' The name of the new unit of time.
'timeunitvalue' The number of old units that the new unit is
equal to.
If either spaceunitname or timeunitname is omitted or empty, no
change will be made to that unit.
Example:
Convert a leaf scaled in microns to millimetres, and from days to
hours:
m = leaf_rescale( m, 'spaceunitname', 'mm', ...
'spaceunitvalue', 1000, ...
'timeunitname', 'hour', ...
'timeunitvalue', 1/24 );
Equivalent GUI operation: the 'Params/Rescale...' menu item.
Topics: Mesh editing.
leaf_rewriteIF.m
m = leaf_rewriteIF( m, ... ) Rewrite the interaction function of m. Normally the interaction function is rewritten the first time that it is called after loading a mesh. This is to ensure that it is always compatible with the current version of GFtbox. Sometimes it is necessary to prevent this from happening. In this case, if it is later desired to force a rewrite, this function can be called. leaf_rewriteIF will do nothing if the i.f. has already been rewritten, unless the 'force' option has value true. Note that a rewrite always happens when a morphogen is added, deleted, or renamed, or when the standard morphogen type (K/BEND or A/B) is changed. Equivalent GUI operation: the Rewrite button on the Interction function panel. Topics: Interaction function.
leaf_rotate.m
m = leaf_rotate( m, type1, rot1, type2, rot2, ... ) Rotate the mesh about the given axes. The rotations are performed in the order they are given: the order matters. Each type argument is one of 'M', 'X', 'Y', or 'Z' (case is ignored). For a type 'M', the following rotation should be a 3*3 rotation matrix. For 'X', 'Y', or 'Z' it should be an angle in degrees. Any sequence of rotations can be given. See also: leaf_rotatexyz. Topics: Mesh editing.
leaf_rotatexyz.m
m = leaf_rotatexyz( m, varargin ) Rotate the coordinates of the leaf: x becomes y, y becomes z, and z becomes z. If the argument -1 is given, the opposite rotation is performed. Equivalent GUI operation: clicking on the "Rotate xyz" button in the "Mesh editor" panel. See also: leaf_rotate. Topics: Mesh editing.
leaf_saddlez.m
m = leaf_saddlez( m, ... )
Add a saddle-shaped displacement to the nodes of m.
Options:
'amount' The maximum amount of the displacement, which is
proportional to the distance from the origin. Default
1.
'lobes' How many complete waves the displacemnt creates on the
edge (an integer, minimum value 2). Default 2.
Example:
m = leaf_saddlez( m, 'amount', 1, 'lobes', 2 );
Equivalent GUI operation: the "Saddle Z" button on the "Mesh editor"
panel. The amount of saddle deformation is specified by the value in
the upper of the two text boxes to the right of the button. The number
of waves is specified by the lower text box.
Topics: Mesh editing
leaf_save.m
m = leaf_save( m, filename, folderpath, ... )
Save the leaf to a file.
The way the leaf is saved depends on the extension of the filename:
.MAT The leaf is saved in a MAT file as a Matlab object called
m.
.M Matlab commands to recreate this leaf are saved in a .M
file.
.OBJ Only the nodes and triangles are saved, in OBJ format.
.MSR Whatever data will fit into MSR format are saved.
.WRL The nodes and triangles, and either vertex or face colours
are saved, in VRML 97 format.
.STL The finite elements are subdivided into tetrahedrons and
saved in STL format.
.FIG The current plot of the leaf is saved as a figure file.
All of these formats except FIG can be read back in by leaf_load.
Note that OBJ format discards all information except the geometry of
the mesh.
If the filename is just an extension (including the initial "."), then
a filename will be prompted for, and the specified extension will be
the default. If no filename is given or the filename is empty, then
one will be prompted for, and any of the above extensions will be accepted.
The folder path specifies what folder to save the file in. If not
specified, then the default folder will be chosen, which depends on the
file extension. If a filename is then prompted for, the file dialog
will open at that folder, but the user can navigate to any other.
If the filename is a full path name then the folder name will be
ignored and the file will be stored at the exact location specified by
filename.
Options:
overwrite: If true, and the output file exists already, it will
be overwritten without warning. If false (the default), the
user will be asked whether to overwrite it.
minimal: For OBJ files, if this is true (the default), then only
the vertexes and triangles of the mesh, and either vertex or
face colours will be written. OBJ files of this
form should be readable by any program that claims to read OBJ
files. If false, more of the information in the
mesh will be written, including all of the morphogen names and
values, in an ad-hoc extension of OBJ format. (The prefix 'mn'
is used for morphogen names, and 'm' for values: each 'm' line
lists all the morphogen values for a single vertex.)
throughfaces: For OBJ files, if this is true, then for every edge
of the mesh, there will be a pair of triangles representing the
quadrilateral connecting the two copies that edge on the two
sides of the mesh. If false (the default), this will only be
done for edges on the rim of the canvas.
bbox: If supplied and nonempty, this is either a bounding box (a
6-tuple [xmin xmax ymin ymax zmin zmax]) or a size (a triple
[xsize ysize zsize]), or a single number size. A single
number size is equivalent to [size size size], and a triple
[xsize ysize zsize] is equivalent to a bounding box [-xsize/2
xsize/2 -ysize/2 ysize/2 -zsize/2 zsize/2]. For OBJ and VRML
format only, the model will be translated and uniformly
scaled so as to best fit into the box.
Equivalent GUI operations: the "Save model..." button (saves as MAT
file) or the "Save script...", "Save OBJ...", or "Save FIG..." menu
commands on the "Mesh" menu.
Topics: Project management.
leaf_savemodel.m
[m,ok] = leaf_savemodel( m, modelname, projectdir, ... )
Save the model to a model directory.
MODELNAME is the name of the model folder. This must not be a full
path name, just the base name of the folder itself. It will be looked
for in the folder PROJECTDIR, if specified, otherwise in the parent
directory of m, if any, otherwise the current directory.
If MODELNAME is not specified or empty, the user will be prompted for a
name using the standard file dialog.
The model directory will be created if it does not exist.
If the model is being saved into its own model directory:
If it is in the initial state (i.e. no simulation steps have been
performed, and the initialisation function has not been called) then
it is saved into the file MODELNAME.mat.
If it is in a later state, it will be saved to MODELNAME_Snnnn.mat,
where nnnn is the current simulation time as a floating point
number with the decimal point replaced by a 'd'.
If the model is being saved into a new directory:
The current state will be saved as an initial state or a later
stage file as above.
If the current state is not the initial state, then the initial
state will be copied across. Furthermore, the initial state of the
new project will be loaded.
The interaction function and notes file will be copied, if they
exist. If the notes file exists, the new notes file will also be
opened in the editor.
Stage files, movies, and snapshots are NOT copied across.
If for any reason the model cannot be saved, OK will be false.
Options:
new: If true, the mesh will be saved as the initial state of a
project, even if it is not the initial state of the current
simulation. The default is false.
strip: If true, as many fields as possible of the mesh will be
deleted before saving. They will be reconstructed as far as
possible when the mesh is loaded. The only information that
is lost is the residual strains and effective growth tensor
from the last iteration. The default is false.
static: If true, the static file of the project will
also be written. If false, not. The default is the value
of ~m.globalDynamicProps.staticreadonly.
Equivalent GUI operation: the "Save As..." button prompts for a
directory to save a new project to; the "Save" button saves the current
state to its own model directory. The "strip" option can be toggled
with the "Misc/Strip Saved Meshes" menu command.
Topics: Project management.
leaf_saverun.m
m = leaf_saverun( m, ... )
Save all the current stage files to a new directory runs/NAME/meshes,
where NAME is supplied in the arguments. In addition, the directory
will contain a file called CommandLine.txt, containing a one-line
description of the set of files.
Options:
name: The name of the directory to store this run.
desc: A one-line description of the run. This is used by
the "Import Experimental Stages..." menu command, which
reads all of the CommandLine.txt files and displays their
contents in a listbox for the user to select one. desc
defaults to name.
verbose: In case of error, if this is true then error messages
will be written to the console. The default is true.
The result OK is true if it succeeded, false if it failed for any
reason.
leaf_savestage.m
[m,ok] = leaf_savestage( m ) Save the current state of the mesh as a stage file. Options: none.
leaf_semicircle.m
m = leaf_semicircle( m, ... ) Create a new semicircular mesh. Parameters are as for leaf_circle. Equivalent GUI operation: selecting "Semicircle" in the pulldown menu in the "Mesh editor" panel and clicking the "New" button. See also: LEAF_CIRCLE, LEAF_CYLINDER, LEAF_LEAF, LEAF_ONECELL, LEAF_RECTANGLE. Topics: Mesh creation.
leaf_set_seams.m
m = leaf_set_seams( m, f_seam_p )
Create seems between the nodes in a given set.
OBSOLETE: use leaf_addseam instead.
Arguments:
f_seam_p: an array giving a real number for every node. Every edge
joining nodes for both of which this value is greater
than 0.5 will be made a seam edge.
See also: leaf_addseam.
Topics: Mesh editing, Seams.
leaf_set_userdata.m
m = leaf_set_userdata( m, ... ) Set fields of the userdata of m. The arguments should be alternately a field name and a field value. You can store anything you like in the userdata field of the canvas. The growth toolbox will never use it, but your own callbacks, such as the morphogen interaction function, may want to make use of it. See also: LEAF_ADD_USERDATA, LEAF_DELETE_USERDATA. Equivalent GUI operation: none. Topics: User data.
leaf_setbgcolor.m
m = leaf_setbgcolor( m, color ) Set the background colour of the picture, and of any snapshots or movies taken. COLOR is a triple of RGB values in the range 0..1. Topics: Plotting.
leaf_setgrowthmode.m
m = leaf_setgrowthmode( m, mode ) Specify whether growth is described by growth and anisotropy, or by growth parallel and perpendicular to the polarisation gradient. Allowable values for MODE are 'ga' or 'pp' respectively. THIS FUNCTION HAS BEEN WITHDRAWN, 2008 May 15. Topics: OBSOLETE.
leaf_setmutant.m
m = leaf_setmutant( m, ... )
Set the mutant level of a morphogen.
Options:
morphogen: The name or index of a morphogen. If omitted, the
mutation properties are set for every morphogen.
value: The value the morphogen has in the mutant state, as a
proportion of the wild-type state.
Examples:
m = leaf_setmutant( m, 'morphogen', 'div', 'value', 0 );
% Set the mutated level of the 'div' morphogen to zero.
Topics: Morphogens.
leaf_setproperty.m
m = leaf_setproperty( m, ... )
Set global properties of the leaf.
The arguments are a series of name/value pairs.
The property names that this applies to are:
'poisson' Poisson's ratio. The normal value is 0.35 and
there is little need to change this.
'bulkmodulus' The bulk modulus. The normal value is 3000 and
there is little need to change this.
'validate' Whether to validate the mesh after every iteration.
This is for debugging purposes and should normally
be off.
'displayedgrowth' Specifies which morphogen to plot.
...and many others I have omitted to document.
Example:
m = leaf_setproperty( m, 'poisson', 0.49 );
Equivalent GUI operation: several GUI elements are implemented by this
command:
poisson: Text box in "Mesh editor" panel.
bulkmodulus: No GUI equivalent.
residstrain: "Strain retention" in "Simulation" panel.
validate: No GUI equivalent.
displayedgrowth: "Displayed m'gen" menu in "Morphogens" panel.
...etc.
Topics: Misc.
leaf_setsecondlayerparams.m
m = leaf_setsecondlayerparams( m, varargin )
Set various general properties of the second layer. If the second
layer does not exist an empty second layer will be created, and the
properties set here will be the defaults for any subsequently created
nonempty second layer.
If m already has a second layer, this procedure does not affect the
colours of existing cells, only the colours that may be chosen by
subsequent recolouring operations.
Options:
colors: An N*3 array of RGB values. These are the colours
available for colouring cells. The special value 'default'
will use the array [ [0.1 0.9 0.1]; [0.9 0.1 0.1] ].
N should be 2. "Ordinary" cells will be coloured with the
first colour, while "shocked" cells will be coloured with
the second colour.
colorvariation: A real number between 0 and 1. When a colour for a
cell is selected from the colour table, this amount of
random variation will be applied to the value selected from
colors. A suitable value is 0.1, to give a subtle
variation in colour between neighbouring cells.
Topics: Bio layer.
leaf_setthickness.m
[m,ok] = leaf_setthickness( m, thickness ) Set the thickness of the leaf everywhere to the specified value. This only affects the current mesh and does not modify any of the static mesh properties. If thickness is being handled non-physically, the effect of this command will be overridden on the next simulation step. In that case you should call leaf_setthicknessparams instead. see also: leaf_setthicknessparams. Topics: Mesh editing.
leaf_setthicknessparams.m
m = leaf_setthicknessparams( m, value )
Set the thickness of the leaf, as a function of its current area.
thickness = K*area^(P/2).
K may have any positive value. P must be between 0 and 1.
When P is 1, K is dimensionless; when P is 0, K is the actual thickness
in length units.
Options:
'scale' K. Default is 0.5.
'power' P. Default is 0.
Topics: Mesh editing, Simulation.
leaf_setzeroz.m
m = leaf_setzeroz( m ) Set the Z displacement of every node to zero. Equivalent GUI operation: the "Zero Z" button on the "Mesh editor" panel. Topics: Mesh editing.
leaf_shockA.m
m = leaf_shockB( m, amount )
AMOUNT is between 0 and 1. Mark that proportion of randomly selected
cells of the A layer with random colours. At least one cell will
always be marked. If there is no A layer, the command is ignored.
Example:
m = leaf_shockA( m, 0.3 );
Equivalent GUI operation: "Shock cells" button on the Bio-A panel.
The accompanying slider and text box set the proportion of cells to shock.
Topics: Bio layer.
leaf_shockB.m
m = leaf_shockB( m, amount )
AMOUNT is between 0 and 1. Mark that proportion of randomly selected
cells of the B layer with random colours. At least one cell will
always be marked. If there is no B layer, the command is ignored.
Example:
m = leaf_shockB( m, 0.3 );
Equivalent GUI operation: "Shock cells" button on the Bio-B panel.
The accompanying slider and text box set the proportion of cells to shock.
Topics: OBSOLETE, Bio layer 2.
leaf_showaxes.m
m = leaf_showaxes( m, axeson ) Make the axes visible or invisible, according as AXESON is true or false. Topics: Plotting.
leaf_snapdragon.m
m = leaf_snapdragon( m, ... )
Make an early stage of a snapdragon flower. This consists of a number of
petals, each of which consists of a rectangle surmounted by a semicircle.
The rectangular parts of the petals are connected to form a tube.
The mesh is oriented so that the cell normals point outwards.
Arguments:
M is either empty or an existing mesh. If it is empty, then an
entirely new mesh is created, with the default set of morphogens
If M is an existing mesh, then its geometry is replaced by the new
mesh. It retains the same set of morphogens (all set to zero
everywhere on the new mesh), interaction function, and all other
properties not depending on the specific geometry of the mesh.
Options:
'petals' The number of petals. Default 5.
'radius' The radius of the tube. Default 1.
'rings' The number of circular rings of triangles to divide
the semicircular parts into. Default 3.
'height' The height of the rectangle, as a multiple of the
semicircle's diameter. Default 0.7.
'base' The number of divisions along half of the base of
each petal. By default this is equal to rings,
i.e. the same as the number at the top of the tube.
'strips' The number of strips of triangles to divide the
tubular part into. If 0 (the default), this will
be calculated from the height so as to make the
triangles similar in size to those in the lobes.
Example:
m = leaf_snapdragon( [], 'petals', 5, 'radius', 2, 'rings', 4 );
See also: LEAF_CIRCLE, LEAF_CYLINDER, LEAF_LEAF, LEAF_ONECELL,
LEAF_RECTANGLE, LEAF_LOBE.
Topics: Mesh creation.
leaf_snapshot.m
[m,ok] = leaf_snapshot( m, filename, ... )
Take a snapshot of the current view of the leaf into an image file.
A name for the image file will be automatically generated if none is
given. If the snapshot cannot be taken or the arguments are invalid then
ok will be returned as false.
Arguments:
1: The name of the file to write. The extension of
the filename specifies the image format. This may be
any format acceptable to the Matlab function IMWRITE.
These include 'png', 'jpg', 'tif', and others.
Options:
'newfile': if true (the default), the file name given will be
modified so as to guarantee that it will not overwrite any
existing file. If false, the filename will be used as given and
any existing file will be overwritten without warning.
'thumbnail': if true (the default is false), the other arguments
and options will be ignored (the filename must be given as the
empty string), and a snapshot will be saved to the file
thumbnail.png in the project directory.
'resolution': Dots-per-inch value. Passing this option will cause
the procedure to use the Matlab function print() instead of
imwrite(), so as to take a picture at whatever resolution you
require. This also has the advantage that as the snapshot is
not performed by grabbing the screen buffer, it does not matter
whether the window is entirely visible on the screen. However,
the image obtained will be of the entire figure window, instead
of just the picture part. If this option is specified with
the empty array as its value, the value currently stored
in m.plotdefaults.hiresdpi will be used. Specifying a value for
resolution does not update m.plotdefaults.hiresdpi: for that,
use leaf_plotoptions( m, 'hiresdpi', ... ).
All remaining arguments will be passed as options to IMWRITE. Any
arguments taken by IMWRITE may be given. If any such arguments are
provided, the filename must be present (otherwise the first argument
for IMWRITE would be taken to be the filename). If you do not want to
provide a filename, specify it as the empty string. The image will be
saved in the 'snapshots' folder of the current project folder, if any,
otherwise the current folder. You can override this by specifying an
absolute path.
Example:
m = leaf_snapshot( m, 'foo.png' );
Equivalent GUI operation: clicking the "Take snapshot" button. This
saves an image in PNG format into a file with an automatically
generated name. A report is written to the Matlab command window.
The 'thumbnail' option is equivalent to the "Make Thumbnail" menu
command.
If stereo mode is turned on, snapshots will be stereo, with the two
images arranged according to the stereo parameters.
See also:
IMWRITE, PRINT
Topics: Movies/Images.
leaf_splitsecondlayer.m
m = leaf_splitsecondlayer( m ) Split every cell in the second layer. Reset the splitting threshold to make the new cell sizes the target sizes. Equivalent GUI operation: "Split L2" button. Topics: Bio layer.
leaf_splitting_factor.m
[m,ok] = leaf_splitting_factor( m, factorname ) Specify the name of a morphogen to use to control edge-splitting, edge-flipping, and retriangulation. Edges will only be modified by these transformations if the value of the morphogen is at least 0.5 at both ends. Specify the empty string as the name to turn this off. Topics: Morphogens, Simulation.
leaf_stereoparams.m
m = leaf_stereoparams( m, ... )
Turn stereo on and off, and change associated parameters.
In stereo mode, the mesh is displayed simultaneously in two different
windows, from the viewpoints of the left eye and the right eye. When
running from the GUI, the main GUI window shows the left eye view and
the second window which appears when stereo is enabled shows the right
eye view. When using a 3D screen that operates by superimposing both
screens in the user's view using polarisers to separate the left and
right eye views, the two windows should automatically appear to be
superimposed on each other.
When stereo is enabled, all snapshots and movies taken will be recorded
in stereo, with the two views composited into a single frame, either
side by side or one above the other.
Options:
'enable' Boolean, turns stereo on or off.
'vergence' The number of degrees each image is rotated. A
positive value (the usual case) means that the image
view directions are what they would be if the eyes
turned inwards to converge on the real 3D object. (This
value is independent of the actual convergence of the
eyes when viewing the stereo images. A typical 3D
display does not require any convergence of the eyes.)
'windowsize' The size in pixels of both of the windows. If the
first window already exists, do not supply this
argument: the second window will automatically be sized
so that its picture is the same size as that in the
first.
'spacing' The number of
pixels separating the centres of the two images in the
combined image. Pass 0 to have the two images abutted.
Pass -1 to specify the screen width or height, as
appropriate to the value of 'direction'. Any empty
space between the images will be filled with the
current background colour.
'direction' A string specifying how the two windows
are placed relative to each other in the
composite frame. The value is one of these strings:
'-h' Right-eye window is placed to the left.
'+h' Right-eye window is placed to the right.
'-v' Right-eye window is placed below.
'+v' Right-eye window is placed above.
The initial default is '-h'
'imagespacing', 'imagedirection' Like spacing, but refers to the
spacing between the two halves of snapshots and movie
frames.
The default for all options is to leave the previous value unchanged.
The initial defaults are 'enable' = false, 'vergence' = 2.5 degrees,
'spacing' = 0, 'direction = '-h', 'imagespacing' = 0, 'imagedirection =
'-h' (which means you have to cross your eyes to fuse the images in
snapshots and movies).
Topics: Movies/Images, Plotting.
leaf_stitch_vertex.m
m = leaf_stitch_vertex( m, dfs )
Constrain sets of vertexes of the mesh so that they move identically.
Arguments:
dfs: a cell array of vectors of degree of freedom indexes. Dfs in
the same vector will be constrained to change identically.
No index may occur more than once anywhere in dfs.
Equivalent GUI operation: none.
Topics: Mesh editing, Simulation.
leaf_subdivide.m
m = leaf_subdivide( m, ... )
Subdivide every edge of m where a specified morphogen is above and/or below
thresholds, and the length of the current edge is at least a certain
value.
NB. This function is currently NOT suitable for calling from an
interaction function. It will go wrong.
Note that this command will subdivide every eligible edge every time it
is called. It does not remember which edges it has subdivided before
and refrain from subdividing them again.
Options:
'morphogen': The name or index of the morphogen
'min': The value that the morphogen must be at least equal to.
'max': The value that the morphogen must not exceed.
'mode': 'all' [default], 'any', or 'mid'.
'minabslength': A real number. No edge shorter than this will be
subdivided.
'minrellength': A real number. This is a fraction of the current
threshold for automatic splitting of edges. No edge
shorter than this will be subdivided. The current
threshold value is returned by currentEdgeThreshold(m).
'levels': The levels of morphogen the new vertices will adopt
'all','interp','none'
'force': If true (the default), all of the requested
subdivisions will happen. If false, edges will not be
split where this would result in excessively small
cells or cell angles.
An edge will be subdivided if and only if it satisfies all of the
conditions that are specified. Any combination of the arguments can be
given. No arguments gives no subdivision.
'mode' is only relevant if 'min' or 'max' has been specified.
If mode is 'all', then each edge is split for which both ends satisfy
the min/max conditions.
If mode is 'any', each edge is split for which either edge
satisfies the conditions.
If mode if 'mid', each edge is split for which the average of the
morphogen values at its ends satisfies the conditions.
This command ignores the setting, that can be set through the GUI or
leaf_setproperty(), that enables or disables automatic splitting of
long edges.
Topics: Mesh editing.
leaf_unshockA.m
m = leaf_unshockA( m )
Restore all cells of the Bio-A layer to their unshocked state.
Example:
m = leaf_unshockA( m );
Equivalent GUI operation: "Unshock all cells" button on the Bio-A panel.
Topics: Bio layer.
leaf_vertex_follow_mgen.m
function m=leaf_vertex_set_monitor(m,realtime,RegionLabels,Morphogens,start_figno) monitor morphogen levels at a set of vertices. Several morphogens can be monitored simultaneously. The results can be recorded and an output in opne figure given over time. The pattern is saved automatically in the model directory.
leaf_vertex_monitor.m
m=leaf_vertex_monitor(m,realtime,RegionLabels,Morphogens,figno)
monitor morphogen levels at individual vertices
m, mesh
realtime, time starting at 0
RegionLabels, vertices to be monitored as designated by cell array of strings, i.e. region labels
Morphogens, cell array of strings, i.e. uppercase morphogen names to
be monitored
figno, figure number ... one figure per morphogen
e.g.
leaf_vertex_monitor(m,realtime,{'POINT1','POINT2'},{'KPAR','POLARISER'},1);
Topics: Simulation.
leaf_vertex_set_monitor.m
function m=leaf_vertex_set_monitor(m,realtime,RegionLabels,Morphogens,start_figno)
monitor morphogen levels at a set of vertices
m, mesh
realtime, time starting at 0
RegionLabels, vertices to be monitored as designated by cell array of strings, i.e. region labels
Morphogens, cell array of strings, i.e. uppercase morphogen names to
be monitored
start_figno, first figure number ... one figure per morphogen
e.g.
leaf_vertex_set_monitor(m,'RealTime',realtime,'ZeroTime',zerotime,...
'REGIONLABELS',{'MEDIAL','MEDIAL'},...
'MORPHOGENS',{'KPAR','APAR'},...
'FigNum',4);
the 'REGIONLABELS' can be 'SEAM' in which case m.seam is used
Topics: Simulation.
leaf_waypointmovie.m
Generate a movie from the currently stored waypoints in m. The options are the same as for leaf_movie. See also leaf_movie, leaf_addwaypoint, leaf_clearwaypoints. Topics: Movies/Waypoints.
compareWithOBJ.m
result = compareWithOBJ( m, fn, varargin )
m is a mesh. fn is the name of an OBJ file which is expected to
contain the node and triangle data for a mesh isomorphic to m.
The remaining arguments are strings naming the comparisons between the
mesh and the OBJ data that are to be returned. Possibilities are:
'distance' The distances between corresponding vertexes.
'area' The ratios of areas of corresponding finite elements are
returned.
...other possibilities may be added if needed.
componentBoundary.m
[bn,ba] = componentBoundary( m, vi ) Given a mesh m and a vertex vi, assumed to be a boundary vertex, set bn to the sequence of vertexes around the boundary starting from v. Set ba to the external angles at those vertexes, i.e. pi minus the sum of the internal angles of the triangles at each vertex. Set be to the lengths of the edges.
componentBoundary2.m
[bn,ba] = componentBoundary( m, vi ) Given a mesh m and a vertex vi, assumed to be a boundary vertex, set bn to the sequence of vertexes around the boundary starting from v. Set ba to the external angles at those vertexes, i.e. pi minus the sum of the internal angles of the triangles at each vertex. Set be to the lengths of the edges.
computeAltitudes.m
m = computeAltitudes( m ) Set m.altitudes to an N*3*3 array such that m.altitudes(ci,cei,:) is the altitude vector in element ci perpendicular to edge cei. m.altratios is set to an N*3 array in which m.altratios(ci,cei) is the ratio in which the foot of the corresponding altitude vector divides the edge.
computeCellGNGlobal.m
gnGlobal = computeCellGNGlobal( v, gaussInfo ) Compute the gradients of the shape functions in the global frame, at every gauss point. v is the set of vertexes of the cell, gaussInfo is the globally constant Gauss point information in isoparametric coordinates.
computeCellsGNGlobal.m
gnGlobal = computeCellsGNGlobal( v, gaussInfo ) Compute the gradients of the shape functions in the global frame, at every gauss point of every cell. v is the set of vertexes of all cells, as a 3*6*n array: v(:,:,i) is the set of 6 vertexes of cell i. the globally constant Gauss point information in isoparametric coordinates. NEVER USED.
computeGNGlobal.m
mesh = computeGNGlobal( mesh ) Compute the gradients of the shape functions in the global frame, at every gauss point in every cell.
computeGaussInfo.m
mesh = computeGaussInfo( mesh ) Compute the gauss points in barycentric coordinates, and the values and gradients of the shape functions there.
computeResiduals.m
m = computeResiduals( m, retainFraction )
Given m.displacements, this computes the following components of
m.celldata:
displacementStrain
residualStrain
If required (i.e. if celldata.actualGrowthTensor exists), it also
computes:
actualGrowthTensor
conductivityMatrix.m
connectedComponent.m
cis = connectedComponent( m, ci ) ci is the index of a cell of m. Find the set of all cells in the strongly connected component of ci, i.e. those cells reachable from ci by traversing edges.
connectedComponents.m
cc = connectedComponents( m ) Find the connected components of m. The result is a cell array of arrays of cell indexes, one for each component, and an array listing for each FE its component. Connected components are defined as being connected across at least an edge. Thus parts connected only at corners will be regarded as separate components, even though they may have one or more vertexes in common. If it is desired to eliminate corner contacts, call SPLITCORNERTOUCH first.
connectedComponentsE.m
[nodeindexes,nodesets,edgeindexes,edgesets,cellindexes,cellsets] = connectedComponentsE( m )
Find the connected components of m by following the edges.
nodeindexes will be an array mapping each node to the index of its
component, and nodesets will be a cell array of the connected
components. For every node n, n occurs in nodesets{nodeindexes(n)}.
convertXYZtoDFs.m
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\growth\converting_movies
MakeVideosAndFLV.m
function MakeVideosAndFLV( max_width, pngs, input_video_folder,input_video_name,finalPicFileName)
based on ---=== VIDEO2FLV ===---
AUTHORS
Vincent Garcia and Sylvain Boltz
1. Convert a video (MPEG, WMV, AVI) into a Adobe Flash Video (FLV). The
conversion process is performed using the FFMPEG application.
max_width, default 0 same as input file, else say 250 for small files
pngs, default 0 none, else 1 for just first and 2 for first and last
frames as pngs
output_video_folder,output_video_name,
output_pngs, default 0, value 1 and it outputs first frame, 2 and it
outputs both the first and last frames
Usage
MakeVideosAndFLV( 400, 0, moviefilepath ,[moviefilename,'.avi'],finalPicFileName );
J. Andrew Bangham, 2011
copyAtoB.m
m = copyAtoB( m ); Copy the A morphogens to the B side. Does nothing if the morphogens are K/BEND style.
copy_experiment_results_back.m
createMeshParamInfo.m
mkparams( internal name, user name, default value, x, y )
createWaypoints.m
create_retrieval_function.m
currentEdgeThreshold.m
currentPanelName.m
currentView.m
cutCells.m
m = cutCells( m, cis ) cis is a set of indexes of cells of m. Split m into two pieces, consisting of the cells cis, and the rest. This does not yet deal with places where the cells may be connected to the rest of the mesh through nodes only and not vertexes.
cutCellsMulti.m
m = cutCellsMulti( m, cs ) cs is a cell array of arrays of cell indexes. cutCells will be called for each member array of cs.
cycle.m
CYCLE( X, N ) return a cyclic permutation of x. N is the amount to rotate x by: cycle(x,1) will return the list resulting from moving the first element of x to the end. N can be any integer.
decayParam.m
defaultMgenColors.m
defaultUserCodeSections.m
definePropertyLists.m
definePropertyLists() This defines some tables of mesh properties, mainly gGlobalProps (the default value of m.globalProps), gGlobalDynamicProps (the default value of m.globalDynamicProps), and gDefaultPlotOptions (the default value of m.plotdefaults). Documentation is interspersed with the definitions which can be automatically extracted and used to populate a Help menu.
deleteAllStagesItem_Callback.m
deleteMgenValues.m
deleteUnusedNodes.m
deleteUnusedStagesItem_Callback.m
deletecell.m
m = deletecell(m,cellstodelete) Delete finite elements from the mesh.
deletepoints.m
deletepointsnearOBS.m
derotate.m
m = derotate( m )
diffusegrowth.m
m = diffusegrowth( m ) Perform one diffusion step for all the diffusible morphogens. This includes decay and clamped values.
dilateSubstance.m
function newg = dilateSubstance( mesh, u, g ) Given a set of vertex displacements u and a vector g of the concentration of a substance at each vertex, calculate the concentration at each vertex after performing the displacements.
dilateSubstances.m
m = dilateSubstances( m, u ) Apply dilateSubstance to each growth factor for which mgen_dilution is true, using the displacements u. Clamped values are not changed.
dilations.m
function d = dilations( m, u ) Given a set of vertex displacements u, calculate the dilution at each vertex after performing the displacements.
disallowNegativeGrowth.m
m = disallowNegativeGrowth( m ) If m.globalProps.allowNegativeGrowth is false, force all growth morphogens to be non-negative.
displayHelpFile.m
displayOutlines.m
displayOutlines( m ) Display the outlines of the flattened connected components of m.
dissect.m
m = dissect( m, separation ) Cut m along all its seam edges. Determine the connected components and separate them.
distunitDlg.m
Begin initialization code - DO NOT EDIT
doEdgeClick.m
doMeshClick.m
doVxClick.m
drawColorbar.m
drawColorbar( h, cmap, crange, cmaptype, backgroundColor ) Draw a color bar filling the axes object h, displaying the colormap cmap, annotated with scale crange. The colorbar is drawn along the longer dimension of h. Does nothing if h is not a handle. The parameters are stored in the userdata, in order to allow for erasing and then restoring the colorbar without requiring a replot. If no parameters are given, the parameters are retrieved from the userdata and the colorbar is redrawn.
drawHistory.m
drawHistoryImage.m
drawLineOnSurface.m
[edges,bc2s,endcell,endbc] = drawLineOnSurface( nodes, edges, startcell,
startbc, heading, distance )
Given a surface defined by a mesh of triangles (nodes,edges
drawThumbnail.m
duplicatenode.m
m = duplicatenode( m, vi, vis ) vis is the set of indexes of duplicates of vertex vi that are to be created. Replicate all of the per-vertex information for vertex vi, for each of the new vertexes.
echoCommand.m
edgeClick.m
This should only be called when the simulation is not running.
edgeData.m
[ edgeVxs, edgeEdges, edgeCells ] = edgeData( m, vi ) If vi is a vertex on the edge of the leaf, find the two edges incident on that vertex, and the vertexes at the other ends of those edges, and the cells that the edges belong to.
edgeListFromNodeList.m
es = edgeListFromNodeList( m, vs ) Find all the edges of the mesh m, both of whose ends are in the set vs. vs must be a vector of vertex indexes of m. es will be a list of edge indexes. See also: edgeMapFromNodeMap
edgeMapFromNodeMap.m
emap = edgeMapFromNodeMap( m, vmap ) Find all the edges of the mesh m, both of whose ends are in the set vmap. vmap must be a vector of booleans of the same length as the number of vertexes of m. emap will be a similar boolean map of the edges. See also: edgeListFromNodeList
edgeincell.m
cei = edgeincell( m, ci, ei ) Return the index of edge ei in cell ci of m. If ei is not an edge os ci, return zero. ci and ei can be vectors of the same length.
edgelengthsq.m
lensq = edgelengthsq(mesh,ei) Return the squared length of edge
ei of the mesh.
edgelengthsqs.m
lengthsqs = edgelengthsqs(mesh) Find squared lengths of all edges.
edgesplinewts.m
elideCells.m
m = elideCells( m, ei, threshold, force ) Shrink the cells on either side of edge ei down to ei, splitting ei in the middle. Threshold is a value of triangle quality such that if any triangle has its quality decreased to a value below the threshold, the transformation will not be done. The default is 0.1. If force is true, the quality criterion will be ignored and the transformation will always be done unless it would make the mesh invalid. The default is false.
elideEdge.m
[m,elided,newedgeindex] = elideEdge( m, ei, threshold ) Shrink the edge ei to a point, and the cells on either side to single edges. The transformation will not be done if it would make the mesh invalid, or if it would reduce the quality of any cell below the threshold. elided is true if the transformation was done. The mesh is not validated afterwards: this should be done after a batch of calls to elideEdge. newedgeindex is the mapping from old edge indexes to new.
eligibleEdges.m
es = eligibleEdges( m ) Return a bitmap of all edges, both ends of which have a corresponding value of splitting morphogen of at least 0.5. If there is no splitting morphogen, all edges are returned.
eliminateEquations.m
(K,f] = eliminateEquations( K, f, rowsToElim, stitchrows, oppositePairs, stitchPairs, oppMoves )
For each i in rowsToElim, delete row i of f and row and column i of K.
For each array in stitchrows, impose the constraint that the
corresponding set of variables are all equal.
For each pair [i,j] in oppositePairs, impose the condition that the
corresponding variables x and y have the property that o-x = o+y,
where o is the corresponding member of oppMoves. When o=0, this is
the condition that x and y are equal and opposite.
For each pair [i,j] in stitchPairs, impose the condition that the
corresponding variables are equal. If any vertex appears in both
oppositePairs and stitchPairs, remove it from stitchPairs and ensure
that its partner in stitchPairs appears in oppositePairs.
eliminateVals.m
remainingVals = eliminateVals( nvals, valsToElim )
Make a list in ascending order of all the integers from 1 to nvals
excluding all values in valsToElim.
emptySelection.m
emptyWaypoint.m
enableMenus.m
enableMenus( handles ) Set the enabled/disabled state of every menu and menu item, depending on the state of the simulation.
enableMutations.m
equivSR.m
p = equivSR( q, T ) Find the continuous strain retention that is equivalent to a discrete strain retention of q with time step T.
equivStrainRetention.m
r1 = equivStrainRetention( t0, t1, r0 ) Compute the value of strain retention for a time step t1 that is equivalent to having strain retention r0 (default zero) at time step t0. t1 must be less than or equal to t0.
estimateGrowth.m
g = estimateGrowth( oldpts, newpts ) oldpts and newpts are N*K matrices (with N > K) containing two sets of N points in K dimensions. estimateGrowth calculates the best-fit growth tensor that will grow oldpts into the shape of newpts in one time unit. Its eigenvectors and eigenvalues are returned as the column matrix v and the columnvector d. g is returned in the frame of reference of newpts, i.e. the best-fit linear transformation of oldpts to newpts is decomposed into g*q where q is a rotation and g is symmetric. This is either the left or right polar decomposition. g and v will be K*K symmetric matrices, and d will be a K*1 vector. oldpts and newpts can be N*K*M matrices, in which case g and v will be K*K*M and d will be K*M.
extendToZero.m
fakemycgs.m
FAKEMYCGS Same arguments and results as MYCGS, but does nothing.
Intended for timing tests of the rest of the program.
feAngle.m
a = feAngle( m, ci, cei ) Compute one angle of the finite element ci.
feAngles.m
a = feAngles( m, ci ) Compute the angles of the finite element ci.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\growth\fecellstuff
cellFEM.m
[k,f] = cellFEM( cell, v, gaussInfo, C, eps0, residualScale )
Calculate the K matrix and force vector for a finite element cell.
Calculate also the pre-strain at each Gauss point (by interpolating eps0).
v: cell vertexes. 3*6 matrix, one column per vertex.
gaussInfo: Gauss quadrature structure in isoparametric coordinates. Includes
the points, and the values and gradients of the shape functions there.
C: compliance matrix. 6*6.
eps0: pre-strain at each vertex (calculated from thermal expansion).
6*6, one column for each vertex. Each column is a 6-vector
representing a 3*3 symmetric tensor.
This also returns in the cell structure the interpolated strains, the
Jacobian of the isoparametric coordinates at each Gauss point, and the
gradients of the shape functions with respect to the global
coordinates at each Gauss point.
computeDisplacementStrains.m
cell = computeDisplacementStrains( cell, displacements ) Set cell.displacementStrain equal to the strain at each Gauss point resulting from the given displacements of the vertexes.
computeResidualStrains.m
cell = computeResidualStrains( cell, retainFraction, vorticities ) Compute the residual strains remaining after applying the given displacements to the vertexes of the cell. We average this over the cell, since for a single FEM element constrained to act linearly, there is no physical meaning to a strain field that varies over the cell.
computeResidualStrainsAA.m
cell = computeResidualStrainsAA( cell, scale ) Compute the residual strains remaining after applying the given displacements to the vertexes of the cell. We average this over the cell, since for a single FEM element constrained to act linearly, there is no physical meaning to a strain field that varies over the cell.
fecell.m
fixCell.m
getFixed.m
showdebug.m
femCellAngles.m
femCellQualities.m
fillstreamlines.m
findBioCell.m
cells = findBioCell( m, pts ) pts is an N*3 array of N points. This function returns an N*1 array specifying for each point, which biological cell it lies within. If it does not lie within any bio cell, the corresponding value will be zero.
findCellAreaAndNormal.m
[a,n] = findCellAreaAndNormal( m, ci ) Compute the normal vector and area of finite element ci of mesh m. We do these together, since this is faster than computing them separately.
findConstrainedNodes.m
findEdgesToElide.m
eis = findEdgesToElide( m ) An edge can be elided if the triangles on both sides have a narrow angle opposite to the edge, and if eliding the edge does not have a bad effect on any triangles.
findElidableEdges.m
findFEareas.m
m = findFEareas( m ) Calculate the area of every cell of the mesh.
findGFtboxFile.m
findHitBC.m
[hitBC,hitPoint] = findHitBC( m, ci, hitLine, normalise ) Given a click on cell ci with the given hitLine, find the barycentric coordinates of the hit point on the cell. If normalise is true (the default), the barycentric coordinates are forced to lie within the cell.
findHitPatch.m
[pi,paramcoordshitPointpt] = findHitPatch( p, hitLine ) Given a patch handle p and a hit line, find which polygon of the path is hit by the line. The polygons are assumed to be either all triangles or all quadrilaterals. WORK IN PROGRESS
findNextEdgeAndCell.m
findNodeFixedDFs.m
vdfs = findNodeFixedDFs( m, vi ) Find which degrees of freedom of the triangular mesh node vi are fixed.
findNodesToSplit.m
[ns,c1s,bc1s,c2s,bc2s,e1s,e2s] = findNodesToSplit( m ) Find nodes of the mesh that require splitting. If no nodes are selected, n will be empty and the other outputs should be ignored.
findPerpVector.m
w = findPerpVector( v ) Returns a unit vector perpendicular to v. v can be a row vector of length 3 or an N*3 matrix of row vectors.
findPolGrad.m
gp = findPolGrad( m, cis ) Calculate the polarising gradient for growth in the specified cells of the mesh, by default all of them.
findProjectDirMenuItems.m
findProjectDirs.m
dirstruct = findProjectDirs( dname )
If dname is not a project directory and contains no project
directories (including the case where dname does not exist), return an
empty array.
Otherwise, return a struct whose elements are:
isprojectdir: boolean, true if the node is a project directory.
When this is true, there should be no children.
name: the full pathname of this directory.
children: a struct array describing the children.
findStopButton.m
b = findStopButton( m ) Find the stop button in the GUI, if present.
findUnusedNodes.m
findVisiblePart.m
m = findVisiblePart( m ) Set m.visible to a structure having the fields 'nodes', 'edges', 'cells', 'borderedges', and 'bordercells'. Each of the first four is a boolean array. The first three indicate which of the respective objects are visible, and the fourth defines the set of edges bordering the visible region. The 'bordercells' field is a column vector of cell indexes, listing the visible cell index bordering each border edge. This is used to implement clipping in leaf_plot and writemeshvrml.
findcellarea.m
findvertexes.m
[v1,v2,v3] = findvertexes( p1, p2, f ) Find where nodes p1 and p2 occur in face f.
We require that p1==f(v1), p2==f(v2), and f(v3) is the third vertex.
Used in the edge-splitting routine SPLITEDGE.
fitmat2.m
m = fitmat( p0, p1 ) P0 and P1 are N*2 or N*3 arrays of 2D or 3D vectors. [M,T] are the linear transformation and translation that best approximate the transformation of P0 to P1. T is P1mean-P0mean, and M is chosen to minimise the squared error of (P1-P1mean) - (P0-P0mean)*M.
fixNodeDFs.m
mesh = fixNodeDFs( mesh, fixedDFs ) Fix all the given degrees of freedom. fixedDFs is an N*s array in which each row contains the index of a node of the triangular mesh and a degree of freedom (1=X, 2=Y, 3=Z). MODE is 'add' to add the constraints to the existing constraints, 'replace' to replace all the existing constraints, and 'delete' to remove these constraints from the existing constraints. The default is 'replace'
fixOrientations.m
m = fixOrientations( m ) Reorder the vertexes of the cells of m so as to give them all a consistent orientation.
fixVertexDF.m
handles = fixVertexDF( handles, vxs, x, y, z ) Fix or unfix the degrees of freedom of a vertex.
fixVertexMgen.m
handles = fixVertexMgen( handles, vi ) Fix or unfix a morphogen at a vertex.
flattenComponents.m
m = flattenComponents( m, interactive, method, cpt, bsiters ) Flatten the indicated components of m. cpt is the index of a component of m, in the arbitrary order in which those components are discovered. It may also be a list of such indexes. By default, it is all of them. As this is quite a time-consuming operation, the process is animated on the screen (provided that INTERACTIVE is true), with progress indicators. If cpt is out of range, it is ignored. BSITERS is a parameter determining how hard it tries to flatten each component. Setting it to zero eliminates the phase of the flattenng process in which, after having laid out the whole mesh in the plane, it tries to adjust the edge lengths to be as close as possible to their lengths in the unflattened mesh.
flipOrientation.m
flipedge.m
m = flipedge( m, eis ) For each ei in eis, ei is the index of an edge that has a triangle on both sides. Those two triangles form a quadrilateral of which the given edge is a diagonal. flipedge replaces that edge by the other diagonal.
flipedges.m
m = flipedges( m ) Find every place where it would improve the mesh to flip an edge, and flip it.
foojava.m
class foo {
int bar;
foo() { bar = 17; }
};
forceFlatThickness.m
m = forceFlatThickness( m ) Set m.prismnodes from m.nodes, assuming a thickness of m.globalDynamicProps.thicknessAbsolute and that the mesh is flat in the XY plane.
forceflat.m
m = forceflat( m ) Force m to be flat and contained in the XY plane. The method first chooses a point on the boundary of m. (If m has no boundary, it isn't flattenable.) That point is mapped to (0,0,0). Its neighbour vertexes, in order, are mapped to points (1,y,0) for value of y in the same order. Their neighbours that we haven't seen already are mapped to (2,y,0), and so on until an entire connected component of m has been mapped. Repeat for every other component, mapping them to the planes z=1, z=2, etc.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\growth\generalFE
completeFEconnections.m
fe = completeFEconnections( fe ) Given a standard FE with just vertexes, edgeends and faceedges defined, construct all the other connectivity data.
standardFEpentahedron.m
fe = standardFEpentahedron() Create a standard pentahedral FE.
generateCellData.m
m = generateCellData( m, cis ) Create the per-cell data structures for the cells listed in cis. The mesh and its globalProps are assumed to have already been computed. If cis is omitted it defaults to all the cells.
generateInteractionFunction.m
generatePlotOptions.m
getAllRealGrowth.m
m = getAllRealGrowth( m )
getAllStageTimes.m
getCellFrame.m
J = getCellFrame( n, p ) J is set to a right-handed unit basis whose first column is parallel to the polarisation gradient P, and whose third is parallel to the cell normal N. If the polarisation gradient is zero, an arbitrary unit vector perpendicular to the cell normal will be chosen instead of the polarisation gradient.
getDisplayedMgen.m
getDisplayedMgenIndex.m
getDraggedView.m
m = getDraggedView( m ) Called by the button-up function after a click-drag to change the view. m has its view parameters updated from the picture.
getFlag.m
--- help for BioMap/getFlag ---
GETFLAG retrieve the 'Flag' property of a BioMap object.
OUT = GETFLAG(OBJ) retrieves the 'Flag' property in a BioMap object.
OUT is an array of integers.
OUT = GETFLAG(OBJ, X) retrieves the 'Flag' property for the elements
indexed by X in a BioMap object. X must be a vector of positive
integers, a logical vector, or a cell array of strings corresponding to
valid 'Header' values. OUT is an array of integers.
Note: Each flag must be interpreted bitwise (0 = false, 1 = true) to
obtain the following information:
0x001: the read is paired in sequencing
0x002: the read is mapped in a proper pair
0x004: the read is unmapped
0x008: the mate is unmapped
0x010: strand of the read (0 = forward, 1 = reverse)
0x020: strand of the mate (0 = forward, 1 = reverse)
0x040: the read is the first in a pair
0x080: the read is the second in a pair
0x100: the alignment is not primary
0x200: the read fails platform/vendor quality checks
0x400: the read is a PCR or optical duplicate
Examples:
% Create a BioMap object.
s = samread('ex1.sam');
obj = BioMap(s);
% Retrieve the 'Flag' value of the second element in the object.
getFlag(obj, 2)
getFlag(obj, {s(2).QueryName})
getFlag(obj, [false true])
% Retrieve the 'Flag' value of the first and third elements in the
% object.
getFlag(obj, [1 3])
getFlag(obj, {s([1 3]).QueryName})
getFlag(obj, [true false true])
% Retrieve the 'Flag' values of all elements in the object.
getFlag(obj)
See also BIOMAP, BIOMAP/GET, BIOMAP/SETFLAG.
Reference page in Help browser
doc BioMap/getFlag
getGFtboxAxes.m
h = getGFtboxHandles( m ) If m is being run from GFtbox, return the GUI handles, otherwise return empty.
getGFtboxConfig.m
Read the GFtbox configuration file and return the config as a struct.
getGFtboxFigure.m
fig = getGFtboxFigure( m ) If m is being run from GFtbox, return a handle to the GFtbox figure, otherwise return empty.
getGFtboxHandles.m
h = getGFtboxHandles( m ) If m is being run from GFtbox, return the GUI handles, otherwise return empty.
getGrowthAmplitudes.m
getHelpText.m
getMatlabViewParams.m
getMeshAxes.m
ax = getMeshAxes( m ) Return an array of all of the axes in which m is plotted.
getMeshCellFrame.m
J, = getMeshCellFrame( m, ci ) J is set to a right-handed unit basis whose first column is parallel to the polarisation gradient, and whose third is parallel to the cell normal. If the polarisation gradient is zero, the first column will be an arbitrary unit vector perpendicular to the cell normal.
getMeshParams.m
mp = getMeshParams( h ) Get the currently selected mesh type and read all of its parameters from the GUI.
getMgenLevels.m
getModelDir.m
getOurViewParams.m
getPlotOptionsFromDialog.m
getRealGrowth.m
gp = getRealGrowth( m, ci ) This function computes the equivalent growth parameters from the displacements of cell ci. The result is a 6-element vector consisting of major growth, minor growth, growth angle, major bend, minor bend, and bend angle.
getRotations.m
r = getRotations( m ) Compute for each finite element the rotation that best approximates the displacements of its vertexes.
getSelectedCompressor.m
getThickness.m
t = getThickness( m ) Return the thickness of the mesh at every vertex.
getViewParams.m
[ourViewParams,matlabViewParams,s] = getViewParams( s )
getnumcells.m
getprismcells.m
getprojectname.m
THIS ROUTINE IS NOT USED ANYWHERE.
globalToLocalGradient.m
locgrad = globalToLocalGradient( globgrad, trinodes ) Compute the barycentric coordinates of the given global vector with respect to the given triangle.
goToProjectDir.m
gradN.m
gn = gradN( p ) Calculate the gradient of all the
shape functions for a triangular prism at isoparametric
coordinates p.
p is a 3x1 column vector.
The result gn is a 3x6 matrix, one column for each shape function.
If p is a 3xN matrix, gn is a 3x6xN matrix.
growmesh.m
MESH = GROWMESH(MESH,DT) Grow the mesh.
growthAnisotropyFromParPerp.m
growthDisplacements.m
[m,U,G,K,F] = growthDisplacements( m ) Calculate plastic growth.
growthFromParPerp.m
growthParPerp.m
growthParallel.m
growthParamsFromTensor.m
Given an N*6 matrix of N growth tensors as row 6-vectors, compute N*1 arrays of the major growth, minor growth, and angle. The growth tensors are assumed to be given in the plane of the cell, i.e. one principal axis is the local z axis.
growthPerpendicular.m
growthRateFromGrowthAmount.m
[ gmajor, gminor ] = growthRateFromGrowthAmount( doublingtime, anisotropy ) Given the time to double in area, and the ratio of the major and minor axes when the area has doubled, compute the growth rates along the major and minor axes.
growthTensorFromParams.m
growthToDouble.m
hSaveNodeBeforeChange.m
hasPicture.m
hexcircle.m
m = HEXCIRCLE(r,n,c) Make a circle triangulated into a hexagon of triangles. R Radius N Number of concentric circles of triangles C Centre
hitmesh.m
ci = hitmesh( m, hitLine ) Return the element of m that is first intersected by the hitline, 0 if there is no such cell. This is rather slow: it tests every element of m for intersection. There are more efficient ways of doing this, but they're not worth the effort of programming.
importRemoteStagesItem_Callback.m
indicateInteractionValidity.m
inflatemesh.m
m = inflatemesh( m ) Reconstruct all the information that was removed from m by stripmesh. See also: STRIPMESH.
initProperties.m
m = initProperties( m )
Set to a default state many fields of m that affect the simulation.
This is convenient to call from your interaction function at time zero,
before initialising the mesh with the values you want.
The following fields are set:
morphogens all set to 0
mgen_production all set to 0
mgen_absorption all set to 0
mgen_dilution all set to 0
mgenswitch all set to 1
mutantLevel all set to 1
allMutantEnabled true
insertFixedDFS.m
v = insertFixedDFS( v, renumber, numfulldfs, stitchDFs, oppositePairs, )
v is a vector indexed by reduced degrees of freedom.
Insert zeros into v so that it is indexed by the full degrees of
freedom.
insertFixedDFS2.m
M = insertFixedDFS2( M, renumber, numfulldfs, stitchDFs )
M is a matrix indexed by reduced degrees of freedom.
Insert zeros into M so that it is indexed by the full degrees of
freedom.
installNewMesh.m
handles = installNewMesh( handles, m ) Install a new, fully constructed mesh into the handles. m is copied to handles.mesh. Various other cross-references between the mesh, the handles, and the GUI are set up. This routine assumes that the simulation is not running.
interpolateVertex.m
m = interpolateVertex( m, v0, v1, v01 ) v01 is a new vertex that has been created at the midpoint of v0 v1. Set all the data for that vertex by suitably interpolating the data for v0 and v1. v0, v1, and v01 may be equal-sizes vectors, in which case the operation is performed for all corresponding elements.
interpolationStencil.m
[ns,ws] = interpolationStencil( m, c, bc ) Given a cell C and barycentric coordinates BC in C, determine the corresponding point on the subdivision surface, in terms of a set of nodes of M and weights. Not fully implemented: this returns the flat subdivision scheme and needs to be revised to use the butterfly.
isCurrentStage.m
isCurrentStage( m ) Test whether M is currently at a stage time, to within 0.1 of the time step.
isDiffusible.m
d = isDiffusible( m, morphogenindex )
d = isDiffusible( c )
The first type of call translates to the second:
d = isDiffusible( m.conductivity(morphogenindex) )
Determine whether the given morpohgens have any non-zero diffusion
coefficients.
isGFtboxBusy.m
isBusy = isGFtboxBusy( handles ) Determine whether the busy flag is set.
isGFtboxProjectDir.m
result = isGFtboxProjectDir( pathname ) Returns TRUE or FALSE depending on whether PATHNAME is a path to a GFtbox project directory. The test is that the directory contain a MAT-file whose basename is identical to the name of the directory.
isValidMgenName.m
isinteractive.m
isint = isinteractive( m ) Determine if m is being processed interactively from within GFtbox. This is deemed to be true if m.pictures is nonempty, m.pictures(1) is a figure handle, and its tag is 'GFTwindow'.
itemStringToSuffixPattern.m
Convert a stage suffix to a pattern that will match any equivalent stage suffix when used as an argument to ls() or dir().
itemStringToSuffixString.m
iterateadj.m
[MESH,vels,force] = ITERATEADJ(MESH,VELS,DT) Perform a single iteration step of a spring graph. PTS is the set of points, VELS is the set of their velocities, and EDGES is the edge data matrix.
kbend_from_ab.m
[k,bend] = kbend_from_ab( a, b ) Given surface growth A and B, compute the equivalent growth and bend factors K and BEND, such that K-BEND = A and K+BEND = B. If ALLOWNEGATIVE is false, force K to be non-negative, at the expense of violating these equalities.
kbend_from_kab.m
[k,bend] = kbend_from_kab( k, a, b ) Given general growth K and surface factors A and B, where the growth on side A is K*A and the growth on side B is K*B, compute the equivalent growth and bend factors K1 and BEND, such that K1-BEND = K*A and K1+BEND = K*B.
keyPanelSwitch.m
latestComputedStageBefore.m
loadIFtemplate.m
loadmesh_anyfile.m
m = loadmesh_anyfile( m, filename, staticdata, interactive )
Load a leaf from a file.
The expected format depends on the extension of the filename:
.OBJ Contains only nodes and triangles, in OBJ format. All
other properties of the mesh will be set to their default
values.
.MAT The leaf is contained in the file as a Matlab object called
m. If staticdata is supplied, data from these overwrites
data loaded from filename. If staticdata is a string, it
will be assumed to be a MAT-file containing the static
data.
.M The file contains Matlab commands to create or modify a
leaf. These commands will be executed.
All of these formats can be generated by leaf_save.
In the case of .OBJ and .MAT files, the existing leaf will be
discarded. A .M file will discard the current leaf only if it contains
a command to create a new leaf.
lobeedges.m
[l,r] = lobeedges( nrings, nrows ) Return two column vectors containing the indexes of the nodes on the left and right edge of the rectangular part of a lobe mesh.
lobemesh.m
m = LOBEMESH(radius, nrings, rectht, nrows, nbase )
Make a mesh in the shape of a semicircle atop a
rectangle. RADIUS is the radius of the semicircle. RECTHT is the
height of the rectangle. NRINGS is the number of rings of triangles
the semicircle is divided into. NROWS is the number of rows of
triangles in the rectangle. NBASE is half the number of edges the base
of the rectangle is divided into. By default this is NRINGS.
The bottom edge of the lobe consists of the last 2n+1 nodes.
The nodes on the right edge are the nth node, and nrows nodes at
intervals of 2nrings+1, ending at the last node.
The resulting mesh contains only the following components:
nodes, tricellvxs, globalProps.trinodesvalid,
globalProps.prismnodesvalid, and borders.{bottom,left,right}.
lobesmesh.m
locateVertexDF.m
handles = locateVertexDF( handles, vxs, x, y, z )
make6vector.m
v = make6vector( m ) Convert a symmetric 3*3 matrix into a 6*1 vector. If m is 2*2 it will be treated as a 3*3 matrix with row 3 and column 3 all zero.
makeAreasAndNormals.m
m = makeAreasAndNormals( m, cells ) Compute the normal vector and area of the given finite elements, by default all of them. We do these together, since this is faster than computing them separately.
makeCanvasPicture.m
fig = makeCanvasPicture( msg, varargin )
Create a figure window containing a canvas picture, legend, report
text, colorbar, etc.
Options:
'figure': An existing figure can be supplied, instead of creating a
new one.
'fpos': The position of the figure on the screen, given as a
four-element array of integers [x y width height]. If a
two-element array is given, it will be interpreted as
[width height], and the figure will be automatically
centered on the screen.
'ppos': The relative position of the picture content elements
within the figure. This is also a four-element array. The
picture elements will be automatically laid out within this
rectangle. If ppos is supplied, fpos is omitted, and a new
figure is being created, then the new figure will be
automatically sized to fit the contents.
'black' A boolean, by default false. If true, the picture will
have a black background, otherwise white.
'add' A boolean, by default true. If false, any existing picture
will be deleted, otherwise it will be retained.
'stereooffset' A real number, by default zero. The number of degrees
of azimuth by which the view will be changed relative to
that indicated by the scrollbar.
'properties' A structure containing any other attribute of the
figure that should be set.
'uicontrols' If true, sliderbars and text items will be created,
otherwise not.
The UserData of the figure will be set to a structure containing
handles to all of the created components, and the Position attribute of
the figure. The latter is needed because when the figure is resized,
this is the only way the resize function has of knowing what the old
size was.
This procedure is also used by the resize callback (ResizeFcn).
If a figure is given to it which already has a nonempty UserData
component, then the UserData is assumed to be a structure as above, and
the components are resized and repositioned as required, instead of
being created. If the figure is found not to have actually changed its
size, the resize function does nothing.
makeCellFrames.m
m = makeCellFrames( m ) Calculate the preferred frame of reference of every cell. Column 1 is the polarisation gradient, column 2 the perpendicular in the plane of the cell, and column 3 the normal to the cell.
makeCircularCrossSection.m
m = makeCircularCrossSection( m, rel_thickness_upper, rel_thickness_lower ) Force the mesh m to have a circular or elliptic cross-section in the XZ plane, assuming the mesh is initially more or less flat in the XY plane. If the semi-diameter of the mesh in the X direction at some point Y is r, then the height of the upper surface of the mesh in the Z direction at X=0 will be r*rel_thickness_upper, and the depth of the lower surface in the -Z direction will be r*rel_thickness_lower. If rel_thickness_lower is not specified, it defaults to rel_thickness_upper, giving elliptical cross-sections symmetric in the plane Z=0. If the original mesh is flat in the XY plane, the resulting mesh will be flat if and only if rel_thickness_upper is equal to rel_thickness_lower.
makeCircularCrossSection2.m
m = makeCircularCrossSection( m, rel_thick_upper, angle_upper, rel_thick_lower, angle_lower ) Force the mesh m to have a circular or elliptic cross-section in the XZ plane, assuming the mesh is initially more or less flat in the XY plane.
makeCitations.m
makeDefaultThumbnail.m
makeDefaultThumbnail( m ) Make a default thumbnail for a mesh. This only does something if m is part of a project and the project has no thumbnail file already.
makeEmptyPlotHandles.m
makeGlobalAxes.m
axes = makeThDiffGlobalTensor( localAngle, xiV, etaV, zetaV )
Construct the set of axes resulting from rotating xiV and etaV about
zetaV by localAngle. xiV, etaV, and zetaV are assumed to be unit
column vectors.
makeGrowthTensor2.m
t = makeGrowthTensor2( majoraxis, majorgrowth, minorgrowth ) Return a 2*2 matrix containing a growth tensor in two dimensions having MAJORGROWTH along MAJORAXIS and MINORGROWTH perpendicular to that.
makeHelpMenu.m
makeIFname.m
ifname = makeIFname( modelname ) Turn an arbitrary string into something that can be a valid Matlab function name or struct field name. The string is mapped to lower case, all non-alphanumerics are replaced by underscore, and if the string does not begin with a letter, it is prefixed by 'IF_'.
makeLocalGrowthTensor.m
G = makeLocalGrowthTensor( gpar, gper, gradpol, gthick, ...
bendpar, bendper )
Compute a growth tensor in the local frame.
makeLocalGrowthTensorNEW.m
G = makeLocalGrowthTensorNEW( apar, aper, bpar, bper, ...
gthick, gradpol, gradpolthresh )
Construct growth tensors for a pentahedral element, given the values of
the growth-determining morphogens at the three vertexes of its midplane.
The result is returned in the frame of its own principal axes, and
therefore the skew components are omitted. A growth tensor is returned
for each vertex; these all have the same principal frame.
apar, aper, bpar, bper are the absolute growth rates on the A and B
sides of the pentahedron.
gradpol is the polarisation gradient.
gthick is the growth in thickness. If this is empty, then thickness is
being handled non-physically, and for the purposes of constructing
growth tensors we use the average of major and minor growth on the
top and bottom.
The result is a set of growth tensors in the global frame of
reference, one for each vertex of the pentahedron. If the triangular
vertexes are v1, v2, and v3, the growth tensors are listed for the
prism nodes in order: v1*2-1, v2*2-1, v1*2, v3*2-1, v2*2, v3*2.
makeMeshGrowthTensors.m
m = makeMeshGrowthTensors( m ) Calculate the growth tensors at every vertex of every cell.
makeMeshLocalGrowthTensor.m
gt = makeMeshGrowthTensor( m, ci ) Calculate the growth tensors at the vertexes of the cell ci in the local frame of ci.
makeModelNamesConsistent.m
m = makeModelNamesConsistent( m )
Update all of the following data so as to be consistent with the folder
name:
The internal model name, m.globalProps.modelname.
The internal projects directory name, m.globalProps.projectdir.
The name of the static file.
The name of the file containing the interaction function.
The name of the notes file.
makeMultiplotWindow.m
make new figure of suitable size
makeNotesName.m
name = makeNotesName( modelname ) Make the name of the notes file for a model m.
makePolygon.m
vxs = makePolygon( mesh, cells ) Assuming that the given FEM cells form a connected region of the mesh with no holes, list the vertexes and edges of the polygon that they form. CELLS is the list of cell indexes. CELLMAP is a bitmap thereof.
makeProjectSubfolders.m
makeTRIvalid.m
makeVertexConnections.m
m = makeVertexConnections( m )
Construct m.nodecelledges, given that all of trinodevxs, edgecells,
edgeends, and celledges are valid.
m.nodecelledges is a cell array indexed by vertexes.
m.nodecelledges{vi} is a list of all of the edges and cells contacting
vertex vi, listed in the same order as are the vertexes of each cell.
Edges and cells alternate; in the sequence e c e', e and e' are edges
of c. Where there is no cell between e and e' (because they are on the
edge of the mesh, c is zero. If the node is on an edge of the mesh,
m.nodecelledges{vi} begins with an edge on the edge of the mesh and
ends with zero.
makeZeroGrowthTensors.m
m = makeZeroGrowthTensors( m ) Set the growth tensors at every vertex of every cell to zero.
makebasis.m
J = makebasis( v1, v2 ) Set J to an orthonormal matrix whose column
vectors j1, j2, j3 are given by:
j1 is parallel to v1.
j2 is in the plane of v1 and v2, and has a positive dot product with
v2.
[j1 j2 j3] is a right-handed basis.
v1 and v2 must be linearly independent non-zero three-element row vectors.
If v2 is not supplied, an arbitrary suitable value will be chosen.
makebendangles.m
m = makebendangles( m, es ) Calculate the angle between element normals across the edges es, by default all of them. For boundary edges this is set to zero.
makecelledges.m
m = makecelledges( m ) Reconstruct the edgecells array, assuming that all the other connectivity information is valid.
makecylindermesh.m
m = makecylindermesh( x, y, centre, height, nx, ny, topcap, basecap, etc... )
Make a cylindrical surface divided into triangles.
x is the radius and y the height.
There are nx cells around and ny cells vertically.
nx must be at least 3 and ny at least 1.
topcap and basecap are booleans: if true, a hemispherical end will
be added to the top or base.
All arguments must be positive.
makeedges.m
m = makeedges( m, ee, ec, ce ) Construct m.edgeends, m.edgecells, m.celledges, and m.seams from m.tricellvxs.
makeedgethreshsq.m
makefig.m
makeleafmesh.m
mesh = makeleafmesh( xwidth, ywidth, xdivs ) Make a leaf-shaped surface. INCOMPLETE.
makeprismsvalid.m
m = makeprismsvalid( m )
Convert 2Dmesh to 3D set of prisms.
makerectmesh.m
m = makerectmesh( x, y, c, nx, ny )
Make a rectangular plate divided into triangles.
If x is a single number, it is the diameter of the mesh along the x
axis. If it is a pair of numbers, it is the minimum and maximum x
value. y is similar.
nx and ny are the number of cells it is subdivided into each way.
nx may be a pair of numbers: in this case the first number is the
number of divisions along the lower edge (lesser y value) and the
second is the number of divisions along the upper edge.
c is the position of the centre of the rectangle.
makestagesuffixf.m
s = makestagesuffixf( t ) Convert a number T to a stage suffix S. T is converted to a stage label, and the stage prefix prepended.
manageMutantControls.m
measureThickness.m
meshAfterTime.m
isat = meshAtOrAfterTime( m, t, tolerance )
Test to see if the current simulation time is after the time T,
allowing for numerical rounding error. The tolerance is a fraction of
the current timestep, and defaults to 0.01. To be counted as after T,
the current time must exceed it by at least this amount.
meshAfterTime( m, t, tolerance ) is exactly equivalent to
~meshAtOrBeforeTime( m, t, tolerance ).
SEE ALSO: meshAtTime, meshBeforeTime, meshAtOrAfterTime,
meshAtOrBeforeTime
meshAtOrAfterTime.m
isat = meshAtOrAfterTime( m, t, tolerance )
Test to see if the current simulation time is at or after the time T,
allowing for numerical rounding error. The tolerance is a fraction of
the current timestep, and defaults to 0.01. Thus function returns true
if the current time does not fall below T by this tolerance or more.
meshAtOrAfterTime( m, t, tolerance ) is exactly equivalent to
~meshBeforeTime( m, t, tolerance ).
SEE ALSO: meshAtTime, meshAfterTime, meshBeforeTime,
meshAtOrBeforeTime
meshAtOrBeforeTime.m
isat = meshAtOrAfterTime( m, t, tolerance )
Test to see if the current simulation time is at or before the time T,
allowing for numerical rounding error. The tolerance is a fraction of
the current timestep, and defaults to 0.01. This function returns true
if the current time does not exceed T by this amount or more.
meshAtOrBeforeTime( m, t, tolerance ) is exactly equivalent to
~meshAfterTime( m, t, tolerance ).
SEE ALSO: meshAtTime, meshAfterTime, meshBeforeTime,
meshAtOrAfterTime
meshAtTime.m
isat = meshAtTime( m, t, tolerance )
Test to see if the current simulation time is close to the time T. The
tolerance is a fraction of the current timestep, and defaults to 0.01.
The function returns true if the simulation time is within this
interval of T.
SEE ALSO: meshAfterTime, meshBeforeTime, meshAtOrAfterTime,
meshAtOrBeforeTime
meshBaryToGlobalCoords.m
meshBeforeTime.m
isat = meshBeforeTime( m, t, tolerance )
Test to see if the current simulation time is after the time T,
allowing for numerical rounding error. The tolerance is a fraction of
the current timestep, and defaults to 0.01. To be counted as before T,
the current time must fall short of it by at least this amount.
meshBeforeTime( m, t, tolerance ) is exactly equivalent to
~meshAtOrAfterTime( m, t, tolerance ).
SEE ALSO: meshAtTime, meshAfterTime, meshAtOrAfterTime,
meshAtOrBeforeTime
meshColors.m
meshDiameter.m
meshFlatStrain.m
mesh = meshFlatStrain( mesh, scale ) Set the residual strain to be the strain the mesh must have, for its relaxed state to be flat. If scale is supplied, the strain is multiplied by that amount
meshFromCells.m
m = meshFromCells( vvxs, vcells ) Create a mesh from a set of biological cells. vvxs is an N*3 array of N vertexes, and vcells is a C*1 cell array listing the vertexes of each cell. centroids, if supplied, is a C*3 array giving the position of a point within each cell. If not supplied, it defaults to the average of all the vertexes belonging to that cell.
meshFromTriangles.m
m = meshFromTriangles( m )
Given a mesh of which the only fields known to exist are m.nodes and
m.tricellvxs, build all of the connectivity information:
m.celledges
m.edgecells
m.edgeends
meshGlobalToBaryCoords.m
meshInfoText.m
meshQueryDialog.m
result = meshQueryDialog( m, numbuttons, format, varargin ) If m is being run interactively, ask the user the question and return the user's response. Otherwise, don't ask, and return 1 (the OK button).
meshThickness.m
ts = meshThickness( m, vis ) Compute the thickness of the mesh at each vertex in vis. If vis is omitted, the thickness at every vertex is returned, as a column vector.
meshZeroStrain.m
mesh = meshZeroStrain( mesh ) Set all residual strains to zero.
mesh_bbox.m
meshbbox.m
meshbboxsize.m
meshgrad.m
g = meshgrad( m, f ) m is a mesh of which at least m.nodes and m.tricellvxs exist, and f is a column vector containing one value for each node. Calculate a N*D matrix g, where N is the number of nodes and D the number of dimensions, in which row i is the gradient vector of f over cell i.
mgenCellGradient.m
g = mgenCellGradient( m, mgen, cis ) For a mesh m, and morphogen field mgen defined at each vertex of m, compute the gradient of mgen for each cell. mgen can be either a morphogen index, a morphogen name, or a row or column vector of values, one for each vertex. This is calculated in the global frame.
mgenColorPick.m
mgenNameFromMgenMenu.m
mgenVertexGradient.m
g = mgenVertexGradient( m, mi ) For a mesh m, and morphogen field mgen defined at each vertex of m, compute the gradient of mgen for each vertex.
mixcolors.m
mixplotoptions.m
fraction is assumed not to be equal to 0 or 1, as these special cases will have been dealt with outside this function. For the interpolable plot options, set those fields in both p0f and p1f to the interpolation of their values from p0 and p1. For non-interpolable fields, set ths of p0f to their values on p0, and those of p1f to their values in p1.
monoColormap.m
[cmap,range] = monoColormap( range, hues ) Create a monochromatic colour map. Hues can be a single colour or a pair of colors. The colors can be specified either as single-letter names: b, w, r, g, b, c, m, y, o; or as hues (single values in the range 0..1); or as rgb colours (a 1*3 or 2*3 matrix).
moreStagesItem_Callback.m
morphogenInteractions.m
g = morphogenInteractions( g ) Calculate the effect of morphogen interaction over a single time step. g is the matrix of morphogens, with one row for every vertex and one column for every morphogen.
mouseeditmodeMenu_Callback.m
--- Executes on selection change in mouseeditmodeMenu.
moveOldRunsToNewRuns.m
moveOldRunsToNewRuns( modeldir ) Move every subdirectory of modeldir/movies which contains a file called "CommandLine.txt" to modeldir/runs.
msrToMesh.m
multicolourmgens.m
multiplotDlg.m
multiplyLayers.m
m = multiplyLayers( m, nlayers ) Replace the mesh of m by nlayers copies, stacked up and with the B surface of one layer glued to the A surface of the next.
mylegend.m
Begin initialization code - DO NOT EDIT
nbvcells.m
cis = nbcells( m, ci ) Find all finite elements that share a vertex with any element in cis.
negativeness.m
neighbourVxs.m
vis = neighbourVxs( m, vi ) Find the vertexes that are the neighbours of vertex vi.
neighbourhoodTension.m
t = neighbourhoodTension( v ) v is an N*2 matrix of row vectors. If each of these represents a tension acting at a point, calculate the stress tensor resulting from the combination of all of them.
newArchiveDirectory.m
a = newArchiveDirectory( adir, basename ) Create a directory whose name has the form basename_Annn. nnn is chosen to be 1 if no such directory exists, or 1 more than the highest number for which such a directory does exist.
newcirclemesh.m
[m,rimnodes] = newcirclemesh( sz, circum, nrings, centre, inner, dealign, sector, coneangle )
newicosmesh.m
m = newicosmesh()
newversioninfo.m
v = newversioninfo( version ) Create version info.
nextborderedge.m
[e,v] = nextborderedge( m, ei, vi ) If ei is the index of a border edge of m, and vi is the index of the vertex at one end of ei, find the index of the other border edge impinging on vi, and the vertex at its other end.
notifyPlotChange.m
notifyPlotChange( handles, varargin ) Set a flag to indicate that the mesh needs to be replotted. Replot the mesh if the simulation is not currently running.
notifySplit.m
Pierre's code goes here.
notifySplits.m
numFEMnodes.m
octagadj.m
MESH = OCTAGADJ(L) Create connection graph of trangulated octagon. L is the radius of the octagon.
octagon.m
OCTAGON(L) Draw a triangulated octagon. L = radius of octagon. The octagon is centred at the origin.
onecell.m
mesh = onecell( x, y ) Make a mesh consisting of a single triangle with vertexes at [0,0,0], [x,0,0], and [0,y,0].
onestep.m
[m,ok] = onestep( m, useGrowthTensors )
Run one step of the iteration:
* Calculate the polarisation gradients.
* Perform a FEM calculation.
* Restore flatness/thickness.
* Perform dilution-by-growth.
* Generate the FEM cell normal vectors.
* Split large FEM cells.
* Recalculate FEM cell areas.
* Recalculate the second layer global positions and split large
second layer cells.
The result OK will be false if the user interrupts in the middle of a
simulation step or there is an error in the interaction function.
openManual_Callback.m
openManual_Callback(hObject, eventdata) Callback for the Help/Open Manual menu item. Open the PDF manual.
openWaypointDialog.m
For testing purposes, MOVIES is a struct array of movies, MI is the index of a movie, and wpi is the index of a waypoint of that movie. In production, the argument will be a mesh from which the waypoints are read, and the indexes will be determined...somehow.
orientMesh.m
m = orientMesh( m ) Force m to be oriented. NOT IMPLEMENTED
othercell.m
ci1 = othercell( m, ci, ei ) If ci is the cell on one side of edge ei, return the cell on the other side, or zero if there is no such cell. ei can be a vector, and ci1 will be a vector of the same length.
otherend.m
vi1 = otherend( m, vi, ei ) If vi is the vertex at one end of edge ei, return the vertex on the other end. ei can be a vector, and vi1 will be a vector of the same length.
othervertex.m
paintVertex.m
if strcmp( selectionType, 'open' ), return; end
paintmesh.m
paintmesh( V, I, res ) Paint the surface through the vertexes V with the image I. res is the grid interval in units of the maximum diameter of V. The vertexes are the rows of V.
parseMgenList.m
mgens = parseMgenList( s )
s is a string containing a list of morphogen names and possibly
morphogen properties. The general syntax is:
mgenname ( propertyname = propertyvalue, ... )
The property names that can be specified are:
d, diff: diffusion constant (default value 0)
dec, decay: decay constant (default value 0)
The result is a struct array with fields 'mgen', 'diff', and
'decay'.
parseStageFileName.m
Take a file name without extension, and look for a stage file suffix. If there is none, return basename as the original name, stagestring as empty, and stagetime as zero. Otherwise, return the stage segment as a string in stagestring (without the leading '_s'), and the corresponding real number in stagetime. If the suffix fails to parse as a number, return stagestring as -1 and stagetime as zero.
partialArea.m
a = partialArea( m, vs ) Calculate the total area of all cells, all of whose vertexes are in the set vs.
partitionCellStrain.m
[Uplanar,Ubending] = partitionCellStrain( U ) U is a 6*3 matrix of the displacements of the vertexes of a cell. Rows 1:3 are one side, and rows 4:6 the other side. This function returns a pair of such matrices, such that U = Uplanar + Ubending and Ubending has equal and opposite components for the top and bottom vertexes of the cell.
perFEtoperVertex.m
perVx = perFEtoperVertex( m, perFE ) Given a quantity that is defined for each finite element, calculate an equivalent quantity per vertex. The per-element quantity can be a vector. If m has numVx vertexes and numFEs finite elements, then perVx has size [numVxs,K] for some K, and perTri has size [numFEs,K]. Note that this is an approximation: some smoothing is unavoidable in the calculation. The function perVertextoperFE translates the other way, but these two functions are not inverses. Converting back and forth will have the side-effect of spreading out the distribution of the quantity.
perVertextoperFE.m
perVx = perVertextoperFE( m, perVx, fes ) Given a quantity that is defined for each vertex, calculate an equivalent quantity per finite element. The per-vertex quantity can be a vector. If m has numVx vertexes and numFEs finite elements, then perVx has size [numVxs,K] for some K, and perFE has size [numFEs,K]. Note that this is an approximation: some smoothing is unavoidable in the calculation. The function perFEtoperVertex translates the other way, but these two functions are not inverses. Converting back and forth will have the side-effect of spreading out the distribution of the quantity.
perturbz.m
ping_cluster.m
planarCellStrain.m
Uplanar = planarCellStrain( U ) U is a 6*3 matrix of the displacements of the vertexes of a cell. Rows 1:3 are one side, and rows 4:6 the other side. Uplanar is set to the planar component of the strain, ignoring the bending at the edges of the cell.
plotConcSummary_20090805.m
Erika 30.01.2009 This tools takes the collected concentration profiles over time from leaf_vertex_follow_mgen.m to create a separate graph for each morphogen with the Distance from the base on the x-axis and the Concentration for morphogens or growth rate in cases of kpar and kper on the y-axis. In leaf_vertex_follow_mgen.m an indivisdual starttime does not seem settable, so that records are always taken right from the start of the simulation.
plotGrowthCrosses.m
plotHighlightedEdges.m
plotMeshGrowth.m
plotMeshPoint.m
plotMinMesh.m
plotMinMesh( m ) Minimal plotting routine that assumes only the node and tricellvxs fields.
plotMinMeshClip.m
plotMinMeshClip( m, n, a ) Minimal plotting routine plus clipping plane. N is a column vector and A is a real number.
plotSecondLayer.m
ph = plotSecondLayer( m ) Draw the second layer.
plotadj.m
PLOTADJ( MESH, VELS, FORCE ) Draw vertexes and edges of a graph. PTS is a 2*n matrix containing the X and Y components of the vertexes of the graph. ADJ is the adjacency matrix: when ADJ(a,b) is nonzero, a line will be drawn from [X(a),Y(a)] to [X(b),Y(b)]. The result is a plot structure.
plotbaremesh.m
plotbaremesh( m ) Plot a mesh which only contains m.nodes and m.tricellvxs.
plotmeshsurface.m
h = plotmeshsurface( theaxes, vxs, triangles, data, pervertex, edgethickness, s ) Plot a triangular mesh.
plotsimplemesh.m
plotspringmesh.m
plotspringmesh(MESH,COLOR,VELS,FORCES) Plot a mesh as a surface.
plottemps.m
PLOTTEMPS(MESH) Plot a mesh as a surface.
plottrimesh.m
plottrimesh( ... ) Simple plot of a mesh. plottrimesh(FILENAME) will read the obj file FILENAME and plot it in the current figure. plottrimesh( V, F ) will plot the triangles specified by V and F. V is an N*3 array of vertexes and F is an M*3 array of vertex indexes. plottrimesh(R), where R has fields V and F will plot R.V and R.F. plottrimesh(M), where M has fields NODES and TRICELLVXS will plot M.NODES and M.TRICELLVXS.
polariseFELayer.m
m = polariseFELayer( m ) Create polarisation vectors for the FE layer. Each vector is a unit vector in the plane of the cell. The directions are chosen randomly.
polariserIndex.m
positiveRainbow.m
posnegMap.m
pp_from_ga.m
prepareProjectNameDialog.m
prismIndexes.m
p = prismIndexes( n ) Calculate the set of prism node indexes corresponding to the given triangle node vertexes.
prismnodesfromnodes.m
processPendingData.m
procrustesHeight.m
procrustesWidth.m
projectVecToLine.m
w = projectVecToLine( v, n ) Find w such that v-w is parallel to n and w is perpendicular to n. n need not be a unit vector. v and n must be row vectors; w will be a row vector.
randInFEMcells.m
r = randInFEMcells( m, cellIndexes, n ) Select n random points from within the given FEM cells.
randomDirection.m
newdir = randomDirection( curstart, radius, curdir, maxangle, surfnormal, insurface, usemaxangle, N ) Generate a random direction that deviates by not more than maxangle from currentdir, and which is uniformly distributed over the spherical cap that is the space of all permitted directions. If surfnormal is supplied, nonempty, and nonzero, limit the new vector to the subset making an angle with surfnormal of more than 90 degrees. If maxangle is empty, all directions are permitted, the same as if maxangle were pi or more. insurface is a boolean. If false, the above happens, but if true, the new direction is constrained to lie parallel to the surface, i.e. perpendicular to surfnormal. (surfnormal must be supplied and nonzero in this case.) The new direction is randomly uniformly distributed over the range of permitted angles in the surface. curdir must be a row vector. newdir will be a unit length row vector. The default value of N is 1. A larger value can be supplied to generate any number of random directions as an N*3 matrix.
randomiseDisplacements.m
readCitationFile.m
readMeshFromOBJ.m
mesh = readMeshFromOBJ( dirname, basename )
Read a mesh from the set of OBJ files in the given directory having the
given basename. If basename is the name of a subdirectory, read the mesh
from the set of files contained in that subdirectory.
It does not matter whether dirname has a trailing '/' or not.
Basename should not contain wildcards.
If basename is empty, dirname will be taken to be the full file name
or directory name.
In each file, comments begin with a #, extend to the end of the
line, and are ignored. Empty lines are ignored. Leading and trailing
space is ignored. Each remaining line is expected to begin with a
token, made of letters, digits, underscores, and hyphens (but hyphens
will be taken as equivalent to underscores). The token is followed by
series of numbers separated by whitespace. The same token must always
be followed by the same number of numbers. Extra numbers will be
ignored and missing numbers set to zero, with a warning printed.
In addition, a line consisting entirely of numbers is allowed: in this
case the implied token name is the file extension (with invalid
characters removed). If the file has no file extension, the basename
of the file is used.
The result of reading the raw data is a structure containing a field
for each different token that was seen. The value of that field is a
matrix in which each row corresponds to a line of data readin from the
files. When reading multiple files, it does not matter which file any
piece of data came from.
2008 Feb 27: readMeshFromOBJ cannot be used to read prim meshes, only
triangular meshes.
readobj.m
o = readobj( filename )
readrawmesh.m
rawmesh = readrawmesh( dirname, basename )
Read a mesh from the set of files in the given directory having the
given basename. If basename is the name of a subdirectory, read the mesh
from the set of files contained in that subdirectory.
It does not matter whether dirname has a trailing '/' or not.
Basename should not contain wildcards.
If basename is empty, dirname will be taken to be the full file name
or directory name.
In each file, comments begin with a #, extend to the end of the
line, and are ignored. Empty lines are ignored. Leading and trailing
space is ignored. Each remaining line is expected to begin with a
token, made of letters, digits, underscores, and hyphens (but hyphens
will be taken as equivalent to underscores). The token is followed by
series of numbers separated by whitespace. The same token must always
be followed by the same number of numbers. Extra numbers will be
ignored and missing numbers set to zero, with a warning printed.
In addition, a line consisting entirely of numbers is allowed: in this
case the implied token name is the file extension (with invalid
characters removed). If the file has no file extension, the basename
of the file is used.
The result of reading the raw data is a structure containing a field
for each different token that was seen. The value of that field is a
matrix in which each row corresponds to a line of data readin from the
files. When reading multiple files, it does not matter which file any
piece of data came from.
2008 Feb 27: readrawmesh cannot be used to read prim meshes, only
triangular meshes.
realStringToItemString.m
realToItemString.m
recalc3d.m
m = recalc3d( m ) Call this after the shape of a mesh has been changed, to recalculate various things that depend on the shape.
recentprojectsMenuItemCallback.m
recomputeStagesItem_Callback.m
recordframe.m
rectifyMeshFOV.m
m = rectifyMeshFOV( m, fov ) Set the field of view to the given value (default 10 degrees), and adjust the camera distance so that in orthographic projection, the visible scene remains unchanged. In perspective projection, the intersection of the view frustum with the target plane will remain unchanged.
rectifyVerticals.m
m = rectifyVerticals( m ) Adjust the positions of the prism nodes on either side of each triangle node, so that the line joining them is parallel to the average of the cell normals of the adjoining cells. The thickness of the mesh at each point is left unchanged.
refineall.m
m = refineall( m ) Split all edges of m, giving a mesh with four times as many cells.
refinemesh.m
mesh = refinemesh( mesh, frac ) Refine a mesh by splitting every edge which is at least as long as the shortest of the longest frac of the edges.
reloadMesh.m
remakeStageMenu.m
renumberMesh.m
m has had vertexes, edges, and cells merged or deleted. rnodes is an array whose length is the number of vertexes of the old version of m. If vi is the index of such a vertex, then rnodes(vi) is the index of the same vertex in the current mesh. If vi has been deleted, rnodes(vi) is zero. Similarly for redges and rcells. The ordering of indexes is assumed to be unchanged. rnodesmap, redgesmap, rcellsmap are boolean maps of the same information in rnodes, redges, rcells. At least one of rnodes or rnodesmap must be supplied; if only one is, the other will be computed from it. The same applies to redges and redgesmap, and rcells and rcellsmap.
replaceNodes.m
m = replaceNodes( m, newm ) Replace m.nodes and m.tricellvxs by newm.nodes and newm.tricellvxs. If newm has prismnodes, replace that also.
requestStagesItem_Callback.m
rescaleSpaceTime.m
m = rescaleSpaceTime( m, spaceunitname, spacescale, timeunitname, timescale ) Choose new units for space and time. m is physically unchanged by this, and therefore its growth behaviour should be unaltered. We could refrain from changing m at all, and merely store the factors that convert between internal units and units displayed to the user. However, it is useful to actually rescale m itself, as a check on the invariance of our calculations to such rescaling. The new space unit is spacescale old units. Therefore all of the numbers that represent distances or positions must be divided by spacescale. Areas must be divided by spacescale^2. Gradients must be multiplied by spacescale. The new time unit is timescale old units. Therefore every numerical time must be divided by timescale. Every rate of change must be multiplied by timescale. Every decay rate must be raised to the power timescale. Every growth rate g should in principle be replaced by (1+g)^timescale - 1; when g is small, this is close to g*timescale. Elasticity coefficients are scale-free. Diffusion constants must be multiplied by timescale/spacescale^2.
resetGlobals.m
resetInteractionHandle.m
m = resetInteractionHandle( m, msg ) Get a handle to the interaction function. This should be called whenever M has been loaded from a file or a new interaction function has been created.
resetView.m
fprintf( 1, '%s\n', mfilename() );
resetView_ButtonDownFcn.m
resetVisibility.m
resetVisibility( handles ) Set the proper visibility of all GUI items. Required when print() corrupts the GUI by making everything visible.
restoreflatness.m
restorethickness.m
retimeSR.m
q = retimeSR( q0, T0, T ) Solve 2(1-q)/T(1+q) = 2(1-q0)/T0(1+q0) for q.
reverseGrowth.m
rewriteInteractionSkeleton.m
ok = rewriteInteractionSkeleton( m, newIFname, newIFdir, msg ) Regenerate the interaction function for M. JAB removed requirement for a leading \n since some editors insert spaces automatically Also, it seems that some versions of Matlab return tokenExtents as a cell array of one element from which the matrix must be extracted.
rimEdges.m
re = rimEdges( m ) This returns information about the edges on the rim of the mesh. re is an N*2 array of the vertex indexes of those edges. ei is a list of the edge indexes. ci is a list of the indexes of the cells they belong to. For each pair of vertexes in ri, they are ordered consistently with their ordering as vertexes of the corresponding cell. The edges are listed in no particular order.
rollzero_ButtonDownFcn.m
rotateAllTensors.m
rotateElastMatrix.m
rotD = rotateElastMatrix( D, J ) D is an elasticity tensor in 6-matrix form. The result is the rotation of D by J, a rotation matrix.
rotateGNglobal.m
g = rotateGNglobal( g, R ) g is a set of 36 vectors as a 3*6*6 matrix, as returned by computeCellGNGlobal. R is a 3*3 rotation matrix. This procedure rotates all the vectors in g by R. NEVER USED.
rotateGrowthTensor.m
rotD = rotateGrowthTensor( D, J ) D is a rank 2 tensor in either 3*3 matrix or 1*6 vector form. The result is the rotation of D by J, a 3*3 rotation matrix in column vector form. Otherwise put, D is the expression of the growth tensor in the frame J, and the result is the growth tensor represented in the global frame. D may also be 3*3*N or N*6, in which case the transformation is applied to every component 3*3 or 1*6 slice.
rotateK.m
k = rotateK( k, R ) Rotate the K matrix by a rotation R in column vector form.
rotateXYZ.m
rotatemesh.m
m = rotatemesh( m, rotmatrix, euleraxes )
Rotate the mesh about the origin by the given matrix.
If ROTMATRIX is a 3*3 matrix, EULERAXES is ignored.
If ROTMATRIX is a vector of one, two, or three numbers, it is
interpreted as a set of Euler angles, about axes specified by
EULERAXES. EULERAXES is a string of characters of the same length as
rotmatrix, consisting of 'X', 'Y', or 'Z'.
rotmatTo6mat4.m
J6 = rotmatTo6mat4( J )
Convert a 3*3 rotation matrix to 6-matrix form, suitable for rotating
elasticity tensors in 6-matrix form.
The following two expressions should give identical results (apart from
rounding error), where s is a symmetric 3*3 matrix and m is a 3*3
rotation matrix:
make6vector( s ) * rotmatTo6mat4( m )
make6vector( m' * s * m )
In fact, they give identical results when m is any 3*3 matrix, although
the interpretation of m'*s*m as a transformation of a symmetric tensor
no longer applies.
rounddec.m
stolen from Peter J. Acklam Erika 30.01.2009
runToButton_Callback.m
runUntilButton_Callback.m
run_Callback.m
saturate.m
c1 = saturate( v, c ) c is an RGB colour. v is a vector of N reals. The results is an N*3 array of N colours, being copies of c saturated by each element of v. Where v is 0, the colour is [1,1,1] (white), and where v is 1, the colour is c, with linear interpolation between. There is no check that v or c are within the range 0..1
saveExperimentStagesItem_Callback.m
saveGFtboxConfig.m
saveStaticPart.m
saveStaticPart( m ) If m is the mesh of a project, save its static part.
savedStages.m
stageTimes = savedStages( m ) Return a cell array of the time suffixes of all the stages for which there is a saved state of the mesh, excluding the initial state.
scalegraph.m
MESH = SCALEGRAPH(MESH,SCALE) Scale a mesh by a real number.
scalevec.m
v = scalevec( v, newmin, newmax )
Scale the entries of the vector so they span the range between
min and max. If all the entries are equal, they are all set to
min.
scalevecs.m
vs = scalevecs( v, len ) Scale the row vectors in vs so that the longest has length len.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\growth\secondlayer
addRandomSecondLayerCell.m
mesh = addRandomSecondLayerCell( mesh, ...
diameter, axisratio, numsides, cloneindex, ...
ci, newci, allowoverlap, cellcolor )
Add a second layer cell at a random position within the FEM cell ci. If
ci is omitted, a random FEM cell will be chosen.
The index of the new cell will be newci; by default, this will be 1
more than the number of existing second layer cells.
The new cell will have NUMSIDES sides. DIAMETER is the diameter of the cell,
in absolute units.
If allowoverlap is false, it will not create the new cell unless it does
not overlap any existing cell.
addRandomSecondLayerClump.m
mesh = addRandomSecondLayerClump( mesh, sz, ci, newci ) Add a second layer clump of seven cells at a random position within the finite element ci. If ci is omitted, a random finite element will be chosen. The index of the new cells will start at newci; by default, this will be 1 more than the number of existing second layer cells.
allocateCells.m
calcCloneVxCoords.m
m = calcCloneVxCoords( m, vxs ) Calculate the 3D coordinates of a list of clone vertexes and install them in the mesh.
calcEdgeData.m
secondlayer = calcEdgeData( secondlayer )
Calculate secondlayer.edges and secondlayer.cells(:).edges from the
other information in secondlayer.
This requires:
secondlayer.cells(:).vxs
secondlayer.vxFEMcell (only to get number of vertexes)
This produces:
secondlayer.cells(:).edges
secondlayer.edges
checkclonesvalid.m
ok = checkclonesvalid( secondlayer ) Make consistency checks of secondlayer.
completesecondlayer.m
m = completesecondlayer( m )
This takes a mesh having a second layer containing only the components
cells(:).vxs(:)
vxFEMcell(:)
vxBaryCoords(:,1:3)
cell3dcoords(:,1:3)
and calculates all the rest.
deleteBoringCells.m
secondlayer = deleteBoringCells( secondlayer ) Delete all second layer cells which are not either shocked or share an edge with a shocked cell.
deleteCellsInFEs.m
secondlayer = deleteCellsInFEs( secondlayer, badFEmap ) This deletes every second layer cell, any vertexes of which lie in any of the finite elements listed in badFEs. This is called by deletecell, which deletes finite elements.
deleteCellsOnBadEdges.m
m = deleteCellsOnBadEdges( m, badedges ) Delete every biological cell which crosses any edge of the finite element mesh listed in badedges. badedges can be a bitmap or an array of indexes. We use a conservative test: every biological cell that has vertexes in two cells joined by a bad edge is deleted. It is possible that a cell is deleted unnecessarily. WARNING: this test is not conservative enough. It is possible for a bio cell to contain vertexes straddling a seam edge, but without it containing vertexes in both of the cells directly bordering the edge.
deleteFemToSecondLayer.m
secondlayer = deleteFemToSecondLayer( secondlayer, oldToNewFEMCell ) After deleting cells from the FEM layer of a mesh, call this to delete every secondlayer cell which has a vertex in any of the deleted FEM cells. oldToNewFEMCell maps old FEM cell indexes to new FEM cell indexes, mapping the deleted cell indexes to zero.
deleteSecondLayerCells.m
secondlayer = deleteSecondLayerCells( secondlayer, cellsToDelete ) cellToDelete is a bitmap of the cells to delete from the second layer.
doSecondLayerClick.m
dumpsecondlayer.m
findBaryPoint.m
[ ci1, bc1 ] = findBaryPoint( mesh, ci, bc ) Given barycentric coordinates bc in cell ci, with one or more negative values, find a point in a neighbouring cell which most closely approximates the given point. UNFINISHED.
findCloneVxCoords.m
mesh = calcFEMcoords( mesh, vxs, mode ) Calculate the 3D coordinates of a list of clone vertexes. If mode==0, the calculation is done on the mid-plane of the FEs. If mode==-1 it is done on the A side, and if mode==1, the B side.
findFEMCell.m
[ ci, bc, bcerr, abserr ] = findFEMCell( m, p, hint ) Find the FEM cell which p is closest to lying inside, and the barycentric coordinates of p in that cell. err is the difference between the resulting point and p. hint is a list of FEM cells to try first. If p does not appear to be in any of them (i.e. its barycentric coordinates are not all positive), then all cells sharing any vertexes with the hint cells are tried.
findbioedgepoint.m
p = findbioedgepoint( m, ci, edgepoint ) m is a mesh and ci is the index of one of its biological cells. ei is an index of an edge of ci. If the vertexes of the endpoints of the edge are at v1 and v2, then p is set to v1*r2 + v2*r1. r2 defaults to 1-r1, giving a weighted average of the two points. If r1=-1 and r2=1, this gives v2-v1, the vector along the edge.
fixSecondLayer.m
m = fixSecondLayer( m, biovxs, hint ) biovxs is a list of biological vertexes lying in cells of m that have just moved. This function recomputes their coordinates, using hint as a list of places to look in first.
hasSecondLayer.m
hexbc.m
bc6 = hexbc( bc, d ) Return the barycentric coordinates of a hexagon centred on bc with radius d.
loadsecondlayer.m
m = loadsecondlayer( x, fi ) Load the Bio-A layer from Andy's data structure.
makeCellGrid.m
m = makeCellGrid( m, spacing ) Create a cellular layer in the form of a regular square grid. The mesh m is assumed to be flat or nearly so.
makeExternCells.m
m = makeExternCells( m, vertexdata, celldata, add ) Create the biological layer from vertexdata, an N*3 array giving the three-dimensional positions of all the vertexes, and celldata, a cell array, each member of which is the list of vertex indexes for one cell. If add is true then the cells will be added to any existing biological layer, otherwise they will replace it.
makeFullSecondlayer2.m
m = makeFullSecondlayer2( m, r ) Create a new second layer for a mesh. R is the refinement, but is not implemented.
makeVoronoiBioA.m
m = makeVoronoiBioA( m, numpoints ) Generate a bio-A layer by the Voronoi method. This only applies if the mesh is flat in the XY plane or nearly so. The layer will contain numBioCells cells.
makeedgedata.m
s = makeedgedata( s ) Given a second layer s containing just the cell vertex index data, construct the cell edge data.
makesecondlayercolorparams.m
cp = makesecondlayercolorparams( colors, colorvariation ) Given an N*3 array of RGB colours and an amount of colour variation expressed in HSV space, calculate an N*6 array, each row of which contains two HSV colours, being the original colours converted to HSV, plus and minus the variation.
mgenPerCell.m
Calculate the average value of the given named morphogen over a given biological cell.
newemptysecondlayer.m
sl = newemptysecondlayer() Create a second layer containing no cells.
numcellsBioA.m
n = numcells( sl ) Find the number of cells in the bio-A layer.
perturbBaryCoords.m
bc1 = perturbBaryCoords( bc ) Randomly perturb the given barycentric coordinates, while keeping them all in the range 0..1 with sum equal to 1.
perturbSecondLayer.m
m = perturbSecondLayer( m, amount ) Randomly move every second-layer vertex by the given amount. The amount is a proportion of the barycentric coordinates.
plotSecondLayerCell.m
ph = plotSecondLayerCell( ci, cellpts, ax, cellcolor ) Plot a single cell of the second layer and return its handle. Arguments are the index of the cell, its vertexes, and its colour.
replaceEdgeEnd.m
e = replaceVertex( e, v1, v2 ) e contains a pair of vertexes. v1 is assumed to equal one element of e. Its occurrence is replaced by v2, and the result is sorted. All other elements of e are undisturbed.
ringbc.m
bcs = ringbc( bc, r, n ) Return the barycentric coordinates of an n-gon centred on bc with radius r.
secondlayerSplitFE.m
secondlayer = secondlayerSplitFE( secondlayer, splitinfo ) The positions of second layer vertexes are defined by the finite element they lie in, and their barycentric coordinates within the element. When a finite element is split by splitalledges, each second layer vertex lying within it must be assigned to one of the descendant finite elements, and its barycentric coordinates with respect to that cell computed. That is done by this function. splitinfo is an array built by splitalledges. It contains one row for every finite element vertex, with six elements [ ci1, ci2, ci3, nc1, nc2, nc3 ]. ci1, ci2, and ci3 are the indexes within the cell of the edges of that cell that were split. If only two edges were split, ci3 is zero, and if only one edge, ci2 is also zero. nc1, nc2, and nc3 are the indexes of the new cells. If only two edges were split, nc3 is zero, and if only one edge, nc2 is also zero. The edges and cells are listed in a canonical order, for which see how they are computed in splitalledges.
secondlayercolor.m
setSecondLayerColorsByArea.m
setSplitThreshold.m
mesh = setSplitThreshold( mesh ) Set the split threshold to be the given multiple of the maximum cell diameter.
splitFEMcell.m
secondlayer = splitFEMcell( secondlayer, femCell, newFemCell, edge ) Recalculate the parent cell and barycentric coordinates when the FEM cell with index femCell splits on the specified edge, with the new cell index newFemCell. The edge is specified by splitv1 and splitv2, which are the FEM vertexes at either end of the split edge, with splitv1 belonging to the old FEM cell and splitv2 belonging to the new FEM cell.
splitSecondLayer.m
m = splitSecondLayer( m ) Split the second layer components where necessary. If m.globalProps.bioAsplitcells, cells larger than a certain size will be split; otherwise, edges longer than a certain amount will be split.
splitSecondLayerCells.m
m = splitSecondLayerCells( m ) Split all second layer cells satisfying certain criteria. If SPLITALL is true, all cells will be split. Otherwise, the choice depends on cell size.
splitSecondLayerEdges.m
m = splitSecondLayerEdges( m ) Split edges of the second layer that are longer than a certain amount.
splitclonecell.m
m = splitclonecell( m, ci, v ) Split cell ci perpendicular to direction v, through splitpoint. splitpoint defaults to the centroid of the vertexes.
splitcloneedge.m
[ vi, bc ] = splitcloneedge( mesh, ei, a, b ) Given a second layer edge ei that is to be split, return the FEM cell and barycentric coordinates of the new point.
spreadBioAtoEdge.m
m = spreadBioAtoEdge( m ) Assuming that the bio-A layer is intended to cover the entire mesh, force it to do so by moving every vertex on the edge of the bio-A layer to the nearest edge of its cell. This is just a special hack to fix a particular mesh and should not be generally used.
selectCurrentTool.m
selectMgenInMenu.m
selectPanel.m
selectProjectMenu.m
separateDFs.m
[x,y,z] = separateDFs( dfs )
setAbsoluteThickness.m
m = setAbsoluteThickness( m, thickness ) Set the current absolute thickness of the mesh everywhere. The thickness parameters are not affected. This procedure should only be used when thickness is implemented physically.
setCheckboxesFromMesh.m
setComponentInfo.m
setDisplayedGrowthMenuStrings.m
setElasticity.m
setFlag.m
--- help for BioMap/setFlag ---
SETFLAG set the 'Flag' property of a BioMap object.
SETFLAG(OBJ, Y) sets the 'Flag' property of a BioMap object OBJ to Y. Y
must be a numeric array.
SETFLAG(OBJ, Y, X) sets the 'Flag' property of the elements indexed by X
in a BioMap object OBJ to the value Y. Y must be a numeric array. X can
be an array of positive integers, a logical array, or a cell array of
strings corresponding to valid 'Header' values.
NOTE: SETFLAG(OBJ,...) without assigning to a variable does not
modify the object's property. Use OBJ = SETFLAG(OBJ,...) to
modify OBJ.
Examples:
% Create a BioMap object with the first 10 elements of the structure s.
s = samread('ex1.sam');
obj = BioMap(s(1:10));
% Create copies of obj and set the 'Flag' value of the second element to zero.
out1 = setFlag(obj, 0, 2)
out2 = setFlag(obj, 0, {s(2).QueryName})
out3 = setFlag(obj, 0, [false true])
% Set the first and third values of 'Flag' in obj.
obj = setFlag(obj, [0 0], [1 3])
% Set all 'Flag' values in the object to 1.
y = ones(1, obj.NSeqs);
obj = setFlag(obj, y)
See also BIOMAP, BIOMAP/GETFLAG, BIOMAP/SET.
Reference page in Help browser
doc BioMap/setFlag
setGFtboxBusy.m
wasBusy = setGFtboxBusy( handles, isBusy )
Set the busy flag and return its previous value.
To ensure that the busy flag displays during execution of a block of
code, bracket it like this:
wasBusy = setGFtboxBusy( handles, true );
...your code...
setGFtboxBusy( handles, wasBusy );
This ensures that whatever value it had previously is restored.
setGUIColors.m
setGUIColors( h ) h is a handle to a GUI object. This routine crawls over h to determine the parent-child relations, then colours the background of items according to their depth in the tree. The figure background is given the backColor, and successively nested panels are given colours tending towards the foreColor.
setGUIMgenInfo.m
setGUIMgenInfo( h ) Cause the GUI to display values relating to a given morphogen. If no mgenIndex is specified, get it from the displayedGrowthMenu item. If there is no mesh, restore default values.
setGUIPlotBackground.m
setGlobals.m
setInitialThickness.m
m.globalProps.thicknessRelative = 0.5; % ... m.globalProps.initialArea^((1 - m.globalProps.thicknessArea)/2) ... / size(m.tricellvxs,2);
setInteractionModeFromGUI.m
setMatlabViewParams.m
setMeshDefaultFields.m
m = setMeshDefaultFields( m ) Given a mesh which may be lacking some of its fields, fill in all the missing ones with default values. There are two reasons for fields to be missing. The mesh may be an old one that needs to be upgraded to the current version of GFtbox, or it may be a newly created one, that has nothing but its geometry present.
setMeshFigureTitle.m
setMeshMultiView.m
setMeshParams.m
fprintf( 1, '%s\n', mfilename() );
setMeshViewFromPicture.m
setMorphogenPanelLabelX.m
setMultiView.m
setMyLegend.m
setNewThickness.m
m = setNewThickness( m, th ) th is a vector of real numbers, one per vertex of the mesh. This routine sets the thickness of the mesh at each vertex to be the corresponding value of th. For this to be effective, m.globalProps.physicalThickness should be set to true.
setNumMorphogens.m
mesh = setNumMorphogens( mesh, n ) Set the number of morphogens of the mesh, either discarding excess morphogens or creating new ones.
setOurViewParams.m
setParPerpMode.m
setPictureColor.m
m = setPictureColor( m, c ) Set the background colour to c, and the foreground colour (the colour of the axes, the legend, etc.) to a colour contrasting with c.
setPictureColorContrast.m
setPictureColorContract( pichandles, c ) Set the background colour to c, and the foreground colour (the colour of the axes, the legend, etc.) to a colour contrasting with c.
setPlotBackground.m
setPlotQuantity.m
setRunColor.m
setRunning.m
setSecondLayerColorInfo.m
m = setSecondLayerColorInfo( m, colors, colorvariation ) Set the colour range for the second layer. This information must be stored in m.globalProps, not m.secondlayer, since it needs to exist even when there is no second layer. colors must be either empty (to get the default green/red colours), a single colour (which will be complemented to get the shocked color), or a pair of colours as a 2*3 matrix. colorvariation is a real number, expressing the amount of random variation allowed for cells nominally of the same colour. The default is 0.1.
setThickness.m
setToolboxName.m
setVertexThicknesses.m
setVertexThicknesses( m, vt ) Set the thickness of m at every vertex. vt is an N*1 array, where N is the number of vertexes of the finite element mesh. SEE ALSO: vertexThicknesses
setViewFromMesh.m
setWaypointTextItems.m
setaxisrangeFromDialog.m
setbowlz.m
M = SETBOWLZ(M,Z) Apply bowl-shaped z-displacement of the mesh.
setconstantfield.m
mesh = setconstantfield(mesh,amount,whichGrowth, add) Set or add constant growth factor for all points.
setedgegrowth.m
setemptymesh.m
setinternalrotation.m
m = setinternalrotation( m, angle )
setlengths.m
MESH = SETLENGTHS(MESH) Set the lengths of all the edges.
setlengthscale.m
mesh = setlengthscale( mesh ) Set mesh.globalProps.lengthscale to the largest diameter of the mesh along the x, y, or z dimensions. This uses the prismnodes data if it is valid, otherwise the nodes data.
setlinearfield.m
mesh = setlinearfield( mesh, maxgf, whichGrowth, direction, add ) Set a field of growth factor with a linear gradient in a given direction.
setmeshfromnodes.m
m = setmeshfromnodes( newmesh, oldmesh ) Complete a mesh structure
which only has tricellvxs and either nodes or prismnodes defined.
If oldmesh is provided, it is assumed to be a complete mesh structure,
and as much information as possible is reused from it.
setmeshgeomfromnodes.m
m = setmeshgeomfromnodes( m ) Given a mesh containing only nodes and tricellvxs, construct the rest of its geometrical and topological information.
setradialfield.m
MESH = SETRADIALFIELD(MESH,INCR,CENTRE) Set growthfactor for all points.
setrestlengths.m
mesh = setrestlengths(mesh) Set resting lengths to current values.
setrestsprings.m
m = setrestsprings( m ) Set the rest lengths and angles of all the springs to their current values. If onlylength is supplied and is true (the default is false), then rest angles and hinge strengths will be set to zero.
setsaddlez.m
MESH = SETSADDLEZ(MESH,Z) Apply saddle-shaped z-displacement of the points in P.
setscalebarsize.m
setstruct.m
setzeroz.m
m = setzeroz( m ) Set z coordinates of the mesh to zero.
shapeN.m
n = shapeN( p ) Calculate the shape functions for a triangular prism
at isoparametric coordinates p. p can be a column vector for a single
point, or a matrix with one column for each point.
sharedEdge.m
[ eci1, eci2 ] = sharedEdge( mesh, ci1, ci2 ) Determine the cell-edge indexes of the edge common to the two cells. Zero if no common edge.
simRunningDialog.m
simStatusString.m
s = simStatusString( m ) Make the report of leaf size, number of iterations, etc. and return it as a string.
simtrumpet.m
fn_arclen( maxs ) Simulated trumpet growth.
singlestep_Callback.m
--- Executes on button press in singlestep. hObject handle to singlestep (see GCBO) eventdata reserved - to be defined in a future version of MATLAB handles structure with handles and user data (see GUIDATA)
sixMatrix.m
M6 = sixMatrix( M3 )
M3 is assumed to be a 3*3 rotation matrix. This function returns
the corresponding 6*6 matrix for transforming a tensor written in
6-vector form.
NEVER USED. Not known if this is correct regarding the issue of doubling
the off-diagonal elements.
sm.m
snapdragonmesh.m
m = snapdragonmesh( petals, radius, rings, height, nbase, nrows )
Make a snapdragon flower.
The resulting mesh contains only the following components:
nodes, tricellvxs, prismnodes, globalProps.trinodesvalid,
globalProps.prismnodesvalid, and borders.{bottom,left,right}.
solve22.m
s = solve22( A, B, C, D, E, F ) Solve the equations ( A B ) ( E ) ( ) s = ( ) ( C D ) ( F )
split2dinterior.m
split2dinterior( edges ) Given a set of unit 2D vectors listed in clockwise order, determine whether this is an opportunity to split the vertex at the centre.
splitAlongEdges.m
m = splitAlongEdges( m, eis ) Split every triangle containing any of the edges in eis into four.
splitBadNodes.m
m = splitBadNodes( m, ang ) Find nodes with incident angles of less than ang, and split as many as possible.
splitSeams.m
m = splitSeams( m ) Split the mesh along its seams. Each vertex on the seam gets S-E new copies, where S is the number of seam edges it lies on and E is 0 for vertexes on the edge of the mesh and 1 elsewhere. Each seam edge becomes two edges, except for seam edges, both of whose ends fail to split. Those seam edges don't split at all and should be removed from the seams.
splitalledges.m
m = splitalledges( m, es, force ) Split all the edges in the list es. If force is true, all the specified edges are split, otherwise an edge will not be split if doing so would make either a cell or an angle too small.
splitchain.m
[ch1,ch2] = splitchain( ch, e1, e2 ) CH is the chain of edges and cells around a node of a mesh. E1 and E2 are edges occurring in that chain. CH1 is set to the subchain from E1 to but not including E2, while CH2 is set to the rest of the chain.
splitcornertouch.m
m1 = splitcornertouch( m ) Wherever there is a node that belongs to cells that share no edges, split that node into as many copies as it takes to eliminate such corner contacts.
splitnode.m
m = splitnode( m, v1, cp1, bc1, cp2, bc2, e1, e2 ) Split node vi of mesh m. The new points are at barycentric coordinates of bc1 in cell cp1 and bc2 in cell cp2. e1 and e2 are the edges of vi which are to be split. e2 is zero if and only if v1 is on the edge of the mesh. If cp1==0, then bc1 is ignored and the first new point coincides with the old point. If cp2==0 then bc2 is ignored and the second new point coincides with the old point.
springEquilibrate.m
m = springEquilibrate( m, iters, frac )
springdisplacementR0.m
d = springdisplacementR0( nodes, edgeends, restlengths, springconst, dt ) Given a set of balls and springs described by NODES, EDGEENDS, RESTLENGTHS, and SPRINGCONST, calculate the displacement of the balls in time DT, assuming that they are immersed in aviscous medium in which the effect of a constant force is to produce a constant velocity equal to that force. The midpoint method is used for the numerical integration.
springforces.m
asd = springforces( m, onlylength ) Calculate the force on each node resulting from the springs of m.
springforces2D.m
[nodeforces,stretches] = springforces2D( nodes, edgeends, restlengths, springconst ) NODES is the set of 2D positions of a set of nodes. EDGEENDS is a list of pairs of nodes. RESTLENGTHS is a vector of floats one for each edge, defining the rest length of that edge. SPRINGCONST is a single number, the spring constant of all the springs. NODEFORCES is the set of resulting forces on the nodes. STRETCHES is a vector of floats, one for each edge, which is the amount by which each edge is stretched from its rest length.
squareadj.m
MESH = SQUAREADJ() Make a triangulated square.
stageMenuItemCallback.m
Find and load the state corresponding to the menu item
stageStringToReal.m
stageTagToString.m
stageTextToTime.m
t = stageTextToTime( s ) Convert a stage suffix of the form 0123d456 to a number 123.456. s may be a cell array, in which case t will be an array of floats. See also: stageTimeToText.
stageTimeToText.m
s = stageTimeToText( t ) Convert a number T to a stage label S. T is converted to a string, and padded out to a fixed length with leading and trailing zeros. The decimal point is replaced by a 'd'. If T is a list of numbers, s will be a cell array of strings. See also: stageTextToTime.
staticBaseName.m
s = staticBaseName( m ) If m is a string, return m concatenated with the static suffix and '.mat.' If m is a mesh, do the same with the model name, provided that m belongs to a project; if not, return the empty string.
stepinternalrotation.m
m = stepinternalrotation( m )
stereoParamsDlg.m
Begin initialization code - DO NOT EDIT
stitchmesh.m
[m,remapnodes] = stitchmesh( m, is, js ) m contains only m.nodes and m.tricellvxs. Make corresponding nodes in is and js identical. remapnodes is set to the renumbering function: remapnodes(i) is the index in the new m of node i of the original m. The nodes being identified with each other will be moved to their midpoint. WARNING: All of the other 3D geometrical information will be recalculated.
stitchmeshes.m
[m,renumber] = stitchmeshes( m1, m2, b1, b2 ) Stitch the two meshes together along b1 and b2. b1 and b2 are lists of node indexes of the same length, of m1 and m2 respectively. The mesh m2 will be translated, rotated and scaled to bring the b2 nodes into coincidence with the b1 nodes. renumber will be set to an array such that renumber(i) is the index in the stitched mesh of node i of m2. The indexes of nodes in m1 are preserved.
stopButton_Callback.m
--- Executes on button press in stopButton.
stopMovie.m
storeCodeRevInfo.m
strainEnergy.m
e = strainEnergy( strain, elasticity ) Compute the energy resulting from the strain and elasticity. Strain is a column 6-vector representing a 3*3 matrix, and elasticity is a 6*6 matrix. The result is strain'*elasticity*strain.
stresscolormap.m
stripmesh.m
m = stripmesh( m, level )
Remove from m all data that can be reconstructed from the
remainder. LEVEL can take three values:
0: (the default) Only delete information that is perfectly
reconstructable.
1: In addition, delete certain information that will be zeroed out
when the mesh is reinflated. This information consists of:
residual strain
...
2: Delete as much information as possible, on the assumption that
the resulting data structure will only be used for visualising
this state of the mesh, and will not be used for further
computation.
See also: INFLATEMESH.
subdivideedge.m
subdivideedgePoints.m
suffixStringToItemString.m
tailLogFile.m
copy project to cluster (without movie directory)
tempdiff.m
temperatures = tempdiff( nodecoords, cellvertexes, conductivity, ...
absorption, production, temperatures, transportfield, dt, ...
lengthscale, fixednodes, cellareas )
Perform a finite-element computation of thermal diffusion.
nodecoords is a numnodes*3 array of coordinates.
cellvertexes is a numcells*3 array of node indexes: each row
lists the node indexes of the three vertices of the cell.
conductivity is one of the following:
* A single number. This is the uniform isotropic thermal
conductivity (divided by the specific heat).
* A vector of numbers, equal in length to the number of finite
elements. This is the non-uniform isotropic thermal
conductivity.
* A 3*3*N matrix, where N is the number of finite elements. This
is the anisotropic thermal conductivity for each finite
element, expressed in the global frame of reference.
temperatures is a vector of numnodes elements, giving the
current temperature at each node.
transportfield contains a vector for every finite element, giving the
direction and rate of flow of the substance in that element. If
this is empty, there is no transport.
dt is the time interval: the result is the vector of new
temperatures after a time dt has elapsed.
lengthscale (UNUSED) should determine the distance the substance
diffuses for a given conductivity and time interval.
fixednodes is a list of those elements of the temperature vector whose
values are assumed to be fixed.
tempdiff3D.m
temperatures = tempdiff3D( nodecoords, cellvertexes, conductivity, ...
absorption, production, temperatures, transportfield, dt, ...
lengthscale, fixednodes, cellareas )
Perform a finite-element computation of thermal diffusion on a 3D mesh.
nodecoords is a numnodes*3 array of vertexes.
cellvertexes is a numcells*6 array of node indexes. Each row lists the
vertexes of one FE in a standard ordering. The A side is [1 2 3],
the B side is [4 5 6], the edges from A to B are [1 4], [2 5], and
[3 6], and the sense is such that the outward normal from B
satisfies the right-hand rule.
tensorComponents.m
[Glocal,J] = tensorComponents( Gglobal ) Gglobal is a growth tensor represented as a 3-vector or a 6-vector. Glocal is set to the three principal components of growth in descending order and J to the corresponding orthonormal frame. The columns of J are the principal axes of the tensor.
tensorsFrom3Displacements.m
tensorsFrom3Displacements( vxs, d ) vxs in an array of three row vectors, being points in 3D space. d is a set of displacements of these points. G is set to a pair [g1,g2] of the principal growth components of the displacements, and J is a frame whose first two axes are the principal directions of growth and whose third is perpendicular to the triangle.
tensorsFromDisplacements.m
[G,Gbend,J] = tensorsFromDisplacements( vxs, d ) NEVER USED.
testRotE.m
testcallback.m
stop = testcallback(m) Callback function for passing to mycgs().
testfeapfile.m
valid = testfeapfile(filename) Load the FEAP file and check its validity.
testhavejava.m
testhist.m
testrkmesh.m
TESTRKMESH(N) Run RKMESH with a predefined set of arguments.
testsliders.m
teststructs.m
profile on;
testtensors.m
textdisplayDlg.m
Begin initialization code - DO NOT EDIT
timeunitDlg.m
Begin initialization code - DO NOT EDIT
toggleFixedCell.m
torture.m
totalGrowth.m
g = totalGrowth( G ) Return the total growth given by the growth tensor G in 6-vector form. This is the determinant of the matrix representation of G.
totalK.m
[m,U,K,F] = totalK( m, useGrowthTensors )
Solve the FEM model for the mesh.
The mesh already contains the temperature at each node and the residual
displacements of the nodes. After the computation, the mesh will contain
the new positions of all the nodes.
The additional results are:
U: the displacements applied to all the nodes. If the computation
fails in a manner that renders U non-meaningful, U will be returned as
empty.
K: The assembled K matrix for the FEM computation.
F: The assembled force vector for the FEM computation.
The mesh is additionally assumed to have the following components:
m.gaussInfo: the Gauss quadrature points for a single cell in isoparametric
coordinates, and the values and gradients of the shape functions at those points.
m.D: the compliance matrix in global coordinates. This will
eventually be replaced by data per cell.
If useGrowthTensors is true (default is false) then growth
tensors have been specified for each cell. Otherwise they are
calculated from the morphogens.
totalStrainEnergy.m
e = totalStrainEnergy( m ) Compute the total strain energy due to the residual strains in the mesh m.
traceStreamline.m
m = traceStreamline( m, ci ) Start a streamline from the centre of the finite element ci. Continue it in both directions until it either hits the edge of the mesh, is reflected back into the FE it just came from, or hits a cell with no gradient.
transferEdgeBC.m
[cj,bc] = transferEdgeBC( m, ci, bc ) Given barycentric coordinates bc of a point on an edge of a cell ci of m, find the barycentric coordinates of the same point relative to the cell on the other side of the same edge. If there is no such cell, cj is returned as zero.
translatemesh.m
transportvectors.m
tv = transportvectors( m, mi )
Calculate the global transport field for morphogen mi, from the local
transport field stored in m.transportfield{mi}.
treeimage.m
triangleIndexes.m
n = triangleIndexes( p ) Calculate the set of triangle node indexes corresponding to the given prism node vertexes.
trianglegradient.m
g = gradient( vertexes, values ) vertexes is a 3*3 matrix of vertex coordinates of a triangle, one vertex in each row. values is a vector of the values that a variable has at each of those vertexes. The result is the gradient vector of that quantity over the triangle, in the global frame.
trimframe.m
f = trimframe( f, sz ) Force the movie frame f to have the given size sz (a two-element vector). If the frame is too big, chop pixels off the edges. If it's too small, pad it out with bgcolor. Maintain the centering of the frame.
truncateCells.m
[vvxs,vcells] = truncateCells( mesh, vvxs, vcells ) Modify the Voronoi tessellation representated by [vvxs,vcells] so that the cells are confined to the FEM cells containing the Voronoi generators. We ignore all cells that include the point at infinity (since we cannot determine the direction of any edge from a finite point to [Inf Inf]). The point at infinity is assumed to be the first vertex in vvxs.
tryElideEdge.m
[m,numElided] = tryElideEdge( m ) Attempts to find an edge of m to elide. It first assesses the quality of each edge (the minimum angle of the cells incident on it), arranges those falling below a threshold in increasing order, and then attempts to elide each one in turn until one succeeds. Elision fails if either it would result in an invalid mesh, or if it would reduce the quality of any cell to a value below the threshold.
trysplit.m
[ m, didsplit ] = trysplit( m ) Split all edges which are longer than the threshold for splitting. Split them in descending order of length. Also split cells bordering an edge where the angle has changed by too much.
ttygrid.m
unfinishedSeams.m
vxs = unfinishedSeams( m ) Find the ends of unfinished seams of m. These are the vertexes lying on exactly one seam and not on the edge of the mesh.
unionmesh.m
m = unionmesh( varargin ) Set m to be the union of the given meshes. The meshes are assumed to be raw, i.e. only nodes and tricellvxs are defined. The same will be true of the result.
unitcellnormal.m
unitnormal = unitcellnormal( m, ci ) Calculate the unit normal vector to element ci of the mesh. The length of the vector is twice the area of the cell. ci can be a vector; the result will be an N*3 array.
unitsfig.m
Begin initialization code - DO NOT EDIT
unixcluster.m
errors=unixcluster(s,m,copymove,filename) Issue the unix command s to the cluster, annotated with the message m. If the command contains the string 'pscp', and copymove is 'move', then filename will be deleted from the cluster. Otherwise, copymove and filename are ignored. J.A.Bangham, 2008
unselectProjectMenu.m
updateAziElScrollFromView.m
updateCreateMorphogensDialog.m
updateElasticity.m
updateFEpolarisation.m
m = updateFEpolarisation( m, w, normalise, alph, generalV ) Replace each polarisation vector by a weighted average of it, its neighbours, and GENERALV. w is the amount of neighbour influence, and alph the amount of general influence, both in the range 0..1.
updateGUIFromMesh.m
h = updateGUIFromMesh( h ) Updates every GUI element that displays a property of the mesh, to be consistent with h.mesh. When h.mesh is empty, it clears all settings to their defaults. If h is a mesh then h will be set to guidata(h.plotdefaults.hfigure). h.plotdefaults.hfigure is assumed to be a GFtbox window. If it does not recognise what h is, it will do nothing.
updateMgenElasticity.m
updateProjectMenuHighlights.m
updateProjectMenuHighlights( handles, selectedDir ) Update the peoject menu highlights so the the path leading to selectedDir is highlighted and all other items are unhighlighted.
updateRecentProjects.m
handles = updateRecentProjects( handles ) A project has just been loaded. Add its project directory to the Recent Projects menu.
updateSelection.m
m = updateSelection( m, vis, cis, eis, selecting ) Update the selection with the given cell, vertex, and edge indices. If SELECTING is 2, replace the selection by the given objects. If SELECTING is 1, add all the given objects to the selection. If SELECTING is -1, remove all the given objects from the selection. If SELECTING is 0, toggle the state of all the given objects.
updateVRMLdialog.m
updateptsSplitFE.m
[fes,bcs] = updateptsSplitFE( fes, bcs, splitinfo ) The positions of a set of points on the surface are defined by the finite element they lie in, and their barycentric coordinates within the element. When a finite element is split by splitalledges, each point lying within it must be assigned to one of the descendant finite elements, and its barycentric coordinates with respect to that cell computed. That is done by this function. splitinfo is an array built by splitalledges. It contains one row for every finite element vertex, with six elements [ ci1, ci2, ci3, nc1, nc2, nc3 ]. ci1, ci2, and ci3 are the indexes within the cell of the edges of that cell that were split. If only two edges were split, ci3 is zero, and if only one edge, ci2 is also zero. nc1, nc2, and nc3 are the indexes of the new cells. If only two edges were split, nc3 is zero, and if only one edge, nc2 is also zero. The edges and cells are listed in a canonical order, for which see how they are computed in splitalledges.
upgradePlotoptions.m
upgradeStaticData.m
s = upgradeStaticData( s, m ) Upgrade any old version of static data to the current version. m, if present, is assumed to be already upgraded to the current GFtbox version. Missing components of s should be defaulted from m, and failing that, from gGlobalProps and gDefaultPlotOptions.
upgradeVeryOldMesh.m
m = upgradeVeryOldMesh( m ) Bring the mesh up to version 0.
upgrademesh.m
m = upgrademesh( m ) Ensure the mesh M is compatible with the current version of the software.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\growth\userinteraction
clearInteractionMode.m
m = clearInteractionMode( m ) Clear the interaction mode.
compatibleInteractionMode.m
compat = compatibleInteractionMode( m, clickMode, varargin ) Determine whether the interaction mode specified by the arguments is compatible with the current mode. In general, compatibility requires that the clickMode, and where applicable, the extra arguments, have not changed. The extra arguments have the same significance as in setInteractionMode.
establishInteractionMode.m
m = establishInteractionMode( m, clickMode, varargin ) Set the interaction mode. If the current mode is compatible with the new mode, is should be updated as necessary with the extra arguments. Otherwise, it should be replaced by the new mode. The extra arguments have the same significance as in setInteractionMode.
setInteractionMode.m
m = setInteractionMode( m, clickMode, varargin )
Replace the current interaction mode by that specified by the arguments.
When clickMode is 'Current mgen' or 'Fixed mgen', varargin{1} is the index
of the selected morphogen, and varargin{2} is the amount.
userinterrupt.m
ui = userinterrupt( sb ) Detect that the user has clicked the stop button. sb is the stop button's graphics handle.
validateChains.m
ok = validateChains( m ) Check the validity of m.nodecelledges, if it exists.
validmesh.m
RESULT = VALIDMESH(M,VERBOSE) Determines whether the mesh is valid. All the connectivity information is checked for consistency. Triangles with very small angles are detected. The morphogen array must be the right size. If VERBOSE is true (default false), messages will be printed to the command window in case of flaws. RESULT will be FALSE if the mesh has fatal errors in it.
vecangle.m
theta = vecangle( a, b ) Return the angle between two row vectors. If n is not supplied, the answer will always be in the range 0..pi. If n is supplied then the answer will be in the range -pi..pi, with the sign positive if the triple (a,b,n) is right-handed and negative if left-handed. a, b, and n can also be N*3 matrices, and theta will be an N*1 vector of angles.
veclen.m
[lensq,len] = veclen(v) Euclidean length and squared length of a vector.
vertexClick.m
This should only be called when the simulation is not running.
vertexThicknesses.m
vt = vertexThicknesses( m ) Calculate the thickness of m at every vertex. The result is an N*1 array, where N is the number of vertexes of the finite element mesh. SEE ALSO: setVertexThicknesses
vertexToCell.m
cellStuff = vertexToCell( mesh, vertexStuff ) Convert a quantity defined per vertex to a quantity defined per cell. The cell value is the average of all the vertex values for vertexes belonging to the cell.
viewScroll_Callback.m
viewWasDragged.m
dragged = viewWasDragged( m ) Discover if the view was changed by dragging in any of m's pictures. If so return true, and set all the drag flags to false.
webify_interaction_function.m
function webify_interaction_function(filename) filename, interaction function filename including suffix J.Andrew Bangham 2011
whoami.m
WHOAMI display user id and retrieve system properties WHOAMI displays a long user id (LID) in the form %time|username|domain|hostname|osarch|osname|osver|MLver WHOAMI optionally returns various system properties including a short user id (SID), which only contains static information about the current system programmers can easily create their own IDs SYNTAX ------------------------------------------------------------------------------- WHOAMI; shows LID in the command window W = WHOAMI; retrieves user/net/cpu IDs only W = WHOAMI(X); retrieves user/net/cpu IDs and system properties INPUT ------------------------------------------------------------------------------- X any number or character OUTPUT ------------------------------------------------------------------------------- W structure with contents according to calling syntax selected fields .sid = short ID without time stamp .lid = long ID with time stamp .res = char array with all system information format: 'fieldname(s): entry' .(fld1:n) = structures of single system properties format: .fieldname(s) = entry NOTE ------------------------------------------------------------------------------- - the JAVA engine must be loaded - system properties are retrieved from java sources InetAddress NTSystem System EXAMPLE ------------------------------------------------------------------------------- whoami; %18-Jun-2008 13:47:52|us|USZ|ws-36362|x86|Windows XP|5.1|7.6.0.324.R2008a w=whoami(1); w.ip % xxx.yyy.192.244 w.file % encoding: 'Cp1252' % separator: '\'
wrapmesh.m
m = wrapmesh( m, r ) m should not contain any components except nodes, prismnodes, globalProps.trinodesvalid, globalProps.prismnodesvalid, and borders. None of these are required. The resulting mesh will have the same components as m.
writeInteractionSkeleton.m
writeMeshInfo.m
Write out the morphogen properties: diffusion, decay, and mutation.
writemeshmsr.m
status = writemeshmsr( filedir, filename, m )
Write the mesh to a file in MSR format.
writemeshobj.m
writemesh( mesh, filedir, filename, surface, minimal )
Write the mesh to a file in extended OBJ format.
If minimal is true (default is false), then only the nodes and cells will
be written, otherwise everything in the mesh is written.
If surface and minimal are both true, the resulting file should be a
standard OBJ file, readable by any software that reads OBJ files.
writemeshstl.m
status = writemeshstl( filedir, filename, m )
Write the mesh to a file in STL format.
writemeshvrml.m
status = writemeshvrml( m, filedir, filename )
Write the mesh to a file in VRML 97 format.
zerogrowth.m
mesh = zerogrowth( mesh, mi ) Set the specified growth factors (by default, all of them) to zero, and their production rates and clamp settings.
zsection.m
[vxs,edgeends,colors] = zsection( m, w, windex ) Determine the intersection of m with a plane perpendicular to one of the axes at value w. windex specifies which axis (1=X, 2=Y, 3=Z), by default 3.
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\guilayouts
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\java
plotBulgeProfile.m
C:\Users\AB\DArT_Toolshed\Toolboxes\GrowthToolbox\testmxmult
time_cgs.m
time_emm.m
time_gels.m
use_culaGels.m
use_culaSgesv.m
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\doc
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\Movies
adjustAgreement.m
agreementDialog.m
analyseHapticPointPlacementTest.m
bezierInterpolation.m
calculateOPTVoxelSize.m
function calculateOPTVoxelSize
chi2TestForHomogeneity.m
function [chi2Stat, expectedValues, testBins] = chi2TestForHomogeneity(observedValues, bins)
Description:
Performs a chi-squared test for homogeneity on the input matrix. Each row is
assumed to be an experiment containing a number of multinomial trials
whose outcomes are recorded in the columns which represent the categories
outcomes can fall in. The matrix must have at least two rows. Note that
this function requires the statistical toolbox to compute the p-value. If
the statistical toolbox is not installed a warning is issued and the p-value
is empty.
Note that the centreBins is assumed to contain the centres of bins and
not the edges. This is relevant only if the called function has to
combine bins, because it calculates a new centre for combined bins. If on
the other hand edges are passed, the result in the testCentreBins will
not be correct, however the statistical test is still valid as the bin
vector itself is not used in the test. It is only returned to provide
additional information.
Author: Johann Strasser
Date: 2009/06/26
chi2TestForPairwiseHomogeneity.m
function [pValuesForPairs, chi2StatsForPairs, expectedValuesForPairs, ...
testObservedValuesForPairs, testBinsForPairs] =
chi2TestForPairwiseHomogeneity(observedValues, centreBins)
Description:
Performs a chi-squared test for homogeneity on all pairs of rows in the input matrix.
Each row is assumed to be an experiment containing a number of multinomial trials
whose outcomes are recorded in the columns which represent the categories
outcomes can fall in. The matrix must have at least two rows. Note that
this function requires uses a function that requires the statistical toolbox
to compute the p-value. If the statistical toolbox is not installed,
the p-values variable is empty.
Note that the length of the last three output variables might not be
equal due to bins being combined by a lower level function to ensure all
expected values are >= 5
Author: Johann Strasser
Date: 2009/06/26
chi2TestStatisticForHomogeneity.m
function [chi2Stat, testObservedValues, expectedValues, testCentreBins] = chi2TestStatisticForHomogeneity(observedValues, centreBins)
Description:
Computes the chi-squared test statistic from a matrix. Each row is
assumed to be an experiment containing a number of multinomial trials
whose outcomes are recorded in the columns which represent the categories
outcomes can fall in. The matrix must have at least two rows.
The function checks iteratively from the tails inward whether any
expected values along a column is not >= five and combines bins if this
is the case. Note that although it checks two adjacent columns at the
same time, a broad spike in the tail might prevent it from proceeding
further inward to a bin which has expected values smaller than 5. Hence no
bins in the interior are being merged. The bin merging procedure was
inspired by the poolbins function in file chi2gov. The function returns
the chi-squared statistic and the associated test data, which might have
bins combined. If bins have not been combined, the returned observed
values and bins are identical to the passed arguments. Note that the bins
vector is assumed to contain centres and not edges.
Other strategies for ensuring the expected values are greater than 5 are
to use larger bins before calling this function or to truncate the
data/bins before calling this function. Though those approaches are
valid they have drawbacks. For instance the former reduces resolution
as it smoothes out the distribution and the latter ignores data. Hence it
is usually best to rely on the bin mergin procedure in this function.
Author: Johann Strasser
Date: 2009/06/26
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\demoData
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\demoData\672clippedA128Cubed
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\demoData\cube_128_subCubeHotSpot_x1p0y1p0z1p0
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\demoData\drosophila (291gfp1+txr+vis)_256Cubed
dummyHeader.m
editHapticVolumePointSet.m
function varargout = editHapticVolumePointSet(varargin) Description: Edit points in a volume using hapticTool. Point coordinates are in the volume's local frame Author: Johann Strasser Date: 090330
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\experimentData
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\experimentDataAdjusted
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\experimentTestData
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\experimentTestData2
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\experimentTestData3
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\experimentTestDataOnLaptop_noStereo
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\foreignCode
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\foreignCode\bezierfitlms_aih
bezcurve.m
function [varargout] = bezcurve(varargin)
Calculates the points along a Bezier curve.
Inputs:
ctrl_pts - the control points for the Bezier
t - the parameterization (time in this case)
Outputs:
bpts - the xy points along the Bezier curve defined by ctrl_pts at time t.
Example:
x = linspace(-1,1,100);
y = x.^3 + randn(size(x))/5;
pts = [x(:), y(:)];
cpts = bezierfitlms('pts', pts, 'order', 4);
bpts = bezcurve('ctrl_pts', cpts, 't', [0:0.001:1]);
See also: bezierfitlms
Dr. A. I. Hanna (2005)
Revision 1: 070821 by Johann Strasser
Extended to provide 3D output in case of 3D control points.
bezierfitlms.m
function [varargout] = bezierfitlms(varargin)
Calculates the control points for a Bezier curve given some data using a
least mean square approach. Note it is important that the point be
ordered in terms of a parameterization, i.e. arc length or time.
Unordered points will result in a poor fit.
Inputs:
pts - the Nx2 data that the Bezier should fit to (default = 100 points for a cubic polynomial)
order - the order of the Bezier curve (default = 3)
verbose - display any output (default = 0)
Outputs:
cpts - a set of Mx2 control points
Example:
bezierfitlms('verbose', 1);
Example:
x = linspace(-1,1,100);
y = x.^3 + randn(size(x))/5;
pts = [x(:), y(:)];
cpts = bezierfitlms('pts', pts, 'order', 4, 'verbose', 1);
plotbezslopes('cpts', cpts, 'parent', gca);
See also: bezcurve
Dr. A. I. Hanna (2006)
Revision 1: 070821 by Johann Strasser
Extended to cater for the case of 3D control points.
plotbezslopes.m
function varargout = plotbezslopes(varargin)
Plots the slopes of the control points for a bezier curve
Inputs:
'cpts' - the control points
'parent' - the axis to draw to (default = gca)
Outputs:
'ph' - the plot handles to the slopes
cpts = bezierfitlms('verbose', 1);
plotbezslopes('cpts', cpts, 'parent', gca);
See also: bezierfitlms, bezcurve
Dr. A. I. Hanna (2007)
Revision 1: 070821 by Johann Strasser
Extended to cater for the case of 3D control points.
getCubeQuadFaces.m
function quadFaces = getCubeQuadFaces() Returns the 6 x 4 matrix containing indices into a vertex array.
getCubeVertices.m
function vertices = getCubeVertices(sideLength) Returns the m x 3 matrix of vertices of a cube with a given side length. The cube is centred around its local coordinate centre
getDefaultHapticPointPlacementTestUserData.m
getDefaultTransformationStructures.m
Set up transformation structures that enables us to specify random translations in x, y and z and random rotations around x, y and z. We use four transformations, one for the translations and three for the rotations. Note that H3D would allow us to make due with only one transformation if we use the rotation around any axis field (Euler axis and angle, also called rotation vector) of the Transform object. However to make initial orientation and finding/setting limits easy we use 3 separate Euler rotations. Also converting Euler angles to a rotation matrix (Direction Cosine Matrix) is trivial, allowing us to easily transform the local points to world space points in Matlab. The order of rotations is x, y, z An initial orientation of 45 degrees around x, -45 around y and 0 around z puts the right top front corner into the middle of the view aligned space Centre screen is x = 45, y = -45 and z = 0
getHTClipPlane.m
[cp] = getHTClipPlane() Utility function to obtain a clip plane structure to be used with the function hapticTool. hapticViewer internally uses hapticToolMex which in turn uses the h3d scene graph api Author: Johann Strasser Date: 070410 (YYMMDD) Revision #1
getHTDefaultOptions.m
getHTIndexedLineSet.m
[ils] = getHTIndexedLineSet() Utility function to obtain an indexed line set structure to be used with the function hapticTool. hapticViewer internally uses hapticToolMex which in turn uses the h3d scene graph api Author: Johann Strasser Date: 070402 (YYMMDD) Revision #1
getHTPointSet.m
[vs] = getHTPointSet() Utility function to obtain a point structure to be used with the function hapticTool. hapticViewer internally uses hapticToolMex which in turn uses the h3d scene graph api Author: Johann Strasser Date: 070129 (YYMMDD) Revision #1 090323 Changed native implementation to be similar to indexed line set
getHTTransform.m
[ts] = getHVTransform(name, parent, matrix) Utility function to obtain a sample transform structure to be used with the function hapticViewer. HapticViewer calls hapticTool which internally uses the scene graph api h3d which. In order to provide user interaction with objects in the scene, transformations are specified intividually. Note that we do not specify a single transformation matrix, due to the H3D's transformation class being a composite transformation. Hence we specify the corresponding components. Below is an excerpt from the H3D reference concerning its transformation class
getHTVolume.m
[vs] = getHTVolume() Utility function to obtain a volume structure to be used with the function hapticTool. hapticTool internally uses hapticToolMex which in turn uses the h3d scene graph api Author: Johann Strasser Date: 070129 (YYMMDD) Revision #1
getHorizontalDistributionTransforms.m
function transforms] = getHorizontalDistributionTransforms(volumes) Description: Function to obtain transforms that distribute volumes horizontally with a given spacing. The number of transforms obtained equals the number of volumes passed Author: Johann Strasser Date: 070326
getImreadSupportedTypesFilterSpec.m
function [filterSpec] = getImreadSupportedFilterSpec() Description: Returns the filterSpec containing all file types supported by function imread. As opposed to getImreadSupportedTypesListFilterSpec this function returns a one-element filter containing all the supported graphics file types at once. Author: Johann Strasser Date: 070312
getImreadSupportedTypesListFilterSpec.m
function [filterSpec] = getImreadSupportedFilterSpec() Description: Returns the filterSpec listing all file types supported by function imread. Author: Johann Strasser Date: 070312
getVoxelSizeFromString.m
function varargout = getVoxelsizeFromString(varargin) Description: Given a string, typically a directory- or filename return a vector containing the voxel size as given in the string Author: Johann Strasser Date: 071105
hapticPointPlacementTest.m
function hapticPlacementTest Description: Tests the speed and accuracy of placing a single point using hapticTool under different combinations of haptics and stereo switched on or off Author: Johann Strasser Date: 090330
hapticPointPlacementTestPrerequisitsDevelopment.m
Make a dummy volume, a 256 cube with full intensity and save it
hapticTool.m
function [transformsOut, volumesOut, pointSetsOut, indexedLineSetsOut, ...
clipPlanesOut] = ...
hapticTool(transforms, volumes, pointSets, indexedLineSets,
clipPlanes, options)
A 3d haptic viewer based on H3DApi.
Author: Johann Strasser
Date: 061123 (YYMMDD)
Revisions:
Date: 090320
Added options structure and therefore changed the calling method
to variable argument list to enable code calling hapticTool
with 5 argument to remain unchanged. Note, however, that we still
assume the same order of arguments as in the old conventional
5 argument interface.
hapticToolDemo.m
function hapticToolDemo()
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\MatlabR2006bMexFiles
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\Microsoft.VC80.CRT
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\Microsoft.VC80.MFC
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\backup
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\hapticToolSolution
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\hapticToolSolution\H3DQTHapticTool
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\hapticToolSolution\H3DQTHapticTool\GeneratedFiles
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\hapticToolSolution\H3DQTHapticTool\GeneratedFiles\debugheavymatlab2007a
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\hapticToolSolution\H3DQTHapticTool\GeneratedFiles\debugmatlab2007a
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\hapticToolSolution\H3DQTHapticTool\GeneratedFiles\releasematlab2007a
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\hapticToolSolution\H3DQTHapticTool\GeneratedFiles\test
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\hapticToolSolution\H3DQTHapticTool\Resources
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\python
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\x3d
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\x3d\settings
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\x3d\settings\default
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\x3d\ui
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\src\hapticToolNative\x3d\ui\textures
loadUserData.m
odefunction.m
dydt = 2 * y; dydt = y .^2;
plot3d_bz_org_intrp_cp.m
% plot original data, interpolated data, control points of bezier curve Mat: original data MatI: approximated (fitted) data p0mat,p1mat,p2mat,p3mat: control points
scratch2.m
smoothIntermediates.m
function [smoothedVertices] = smoothIntermediates(vertices, indices)
smoothPathDemo.m
Input path points and save
temp.m
viewVolume.m
function viewVolume(varargin) Description: Utility function that enables users to view a volume given the path and name of a volume directory containing the image slices in any image format known to Matlab. If no volume directory is given users are presented with an open file dialog to choose a volume slice. All images with the same extension in the same directory are assumed to compose the volume. Specifying path in this case causes the file dialog to open in that location which. Keeping the volume directory and the path to it separate increases reusability of the function as it makes it useful in the context of other programs that maintain the notion of a project. Furthermore if both the path and the volume directory are specified, a third parameter stipulating the image file type has to be present. For instance to invoke the viewer without presenting a file dialog use the following function call syntax:
C:\Users\AB\DArT_Toolshed\Toolboxes\HapticToolbox\volumeUtils
clipVolume.m
function varargout = clipVolume(varargin) Description: Clip a volume (single or rgb) given one or more plane equations in volume space Author: Johann Strasser Date: 071111
clipVolumeTool.m
function varargout = clipVolumeTool(varargin) Description: GUI tool for clipping a volume Author: Johann Strasser Date: 080103
getPlaneEquationFromPointAndNormal.m
function equation = getPlaneEquationFromPointAndNormal(point, normal) Description: Get coefficients of plane equation. Ax + By + Cz + D = 0 is the plane equation. Refer to http://mathworld.wolfram.com/Plane.html on how to derive the plane equation from a point and a normal (dot product). Author: Johann Strasser Date: 080107
getPolylineLength.m
function l = getPolylineLength(vertices) Description: Calculate the length of a polyline which is defined as a series of vertices. Each row is assumed to be a vertex, i.e. for 3D vertices the argument must be an m x 3 array. Author: Johann Strasser Date: 071122
imBatchCrop.m
IMBATCHCROP crops a batch of image files of type JPG, TIF, GIF, BMP
and PNG.
syntax:
imBatchCrop(rect)
description:
imBatchCrop crops batch of images to a specified rectangle. Images
are saved in the same format as the original file and in a
subdirectory named CroppedImage. A postfix '_cropped' is added to
the original name of the file.
rect is a four-element vector with the form [xmin ymin width height];
these values are specified in spatial coordinates.
fmt is the image format of the ouput images.
Note: to obtain 256x256 images with top left corner at position (100,50)
the parameter rect should be rect = [100 50 255 255].
see also imcrop
Dr. Blot (Dec. 2006)
imBatchResize.m
IMBATCHRESIZE resises a batch of imsge files of type JPG, TIF, GIF, BMP
and PNG.
syntax:
imBatchResize(option)
description:
resizes images using opiton arguments of the imresize function of
matlab. Images are saved in the same format as the original file
and in a subdirectory named ResizedImage. A postfix '_resized' is
added to the original name of the file
see also imresize
Dr. Blot (Dec. 2006)
indexedLineSet2PolylineStructs.m
function varargout = indexedLineSet2PolylineStructs(varargin) Description: Convert an indexed line set into a polyline structures. Author: Johann Strasser Date: 071122
loadVolumeFromSlicesDir.m
function varargout = loadVolumeFromSlicesDir(varargin) Description: Function to load slices given the directory where the slices reside. The matlab supported image formats are tried in turn to load a volume comprising image slices in the given directory. As soon as one or more image files of a given type are encounterd, all the images with the given extension are assumed to comprise the volume and image search stops. Author: Johann Strasser Date: 070326
loadVolumeFromSlicesDirTyped.m
function varargout = loadVolumeFromSlicesDir(varargin) Description: Function to load slices given the directory where the slices reside and the extension of the graphics file type. Author: Johann Strasser Date: 070312
makeMovie.m
imreadSupportedFileTypes = getImreadSupportedTypesFilterSpec();
[f, p] = uigetfile('bmp', 'Choose volume slice');
if isequal(fileName, 0)
disp('User selected cancel.');
userCancel = 1;
else
[fullVolumePath, name, extension, versn] = fileparts(fullfile(p, f));
end
measureVolumeTool.m
function varargout = measureVolumeTool(varargin) Description: GUI tool for taking simple polyline measurements in volumetric data Author: Johann Strasser Date: 071120
resizeVolume.m
function varargout = resizeVolume(varargin) Description: Resize a volume given one or three scale factors using one of two algorithms: Algorithm 1: A simple nearest neighbour implementation in the z dimensions. Matlab's imresize function is used to resize in the x and y dimensions. Note that choosing the simple algorithm and specifying cubic interpolation will result in nearest neighbour interpolation in the z dimension and cubic interpolation in the x and y dimensions. Algorithm 2; Utilises Matlab's n-dim spatial transformation function. Note that in contrast to imresize this method does not seem to take into account neighbouring pixels when the resize factor is 1/someInteger , i.e. 0.5, 0.25, etc., even though cubic interpolation was specified. For scaling up or non 1/someInteger factors this method in conjunction with cubic interpolation is recommended. Author: Johann Strasser Date: 071111
resizeVolumeDemo.m
function resizeVolumeDemo
resizeVolumeTool.m
function varargout = resizeVolumeTool(varargin) Description: GUI tool to resize a volume Author: Johann Strasser Date: 071111
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\ja_scripts
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\path
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\archive
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\cache
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\category
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\commonsdelinker
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\commonsdelinker\plugins
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\copyright
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\deadlinks
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\disambiguations
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\families
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\featured
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\interwiki-dumps
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\interwiki-graphs
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\login-data
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\logs
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\maintenance
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\mediawiki-messages
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\simplejson
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\spelling
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\userinterfaces
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\watchlists
C:\Users\AB\DArT_Toolshed\Toolboxes\MediawikiToolbox\wikiscripts\pywikipedia\wiktionary
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleAnalysis
Chains2mat.m
MicrotubuleAnalysis.m
MicrotubuleAnalysis Tool to analyse EB1 spots in sequences of microtubule images see also (first get to a position where data.ad has been populated checkSpotPairs used to compute probability of an edge between two spots using correlation histoSpotProperties.m to histogram properties of spots that are in chains < and >= a particular length Paul Southam and Andrew Bangham, 2011
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleAnalysis\MtMaker
makeMTfigure.m
function makeMTfigure(figno,ScottsData) figno, default 1 ScottsData Usage copy the Data and DiffData directories into a new project
readScottsData.m
ProbTwoSpotsInLine2.m
first get a set of refined chains then use this
ProbTwoSpotsInLine3.m
improved by allowing weighting by spot separation and weighting by spot intensity
data
spots, two spots (from allspots) each spot has a number of points with associated image/spot values
type, default 0, i.e. do not use either spot or point intensity,
1 use point intensity i.e. wXY see regionprops_improved
2 not point intensity, but use spot intensity
3 use point intensity and spot intensity
separation_weight, default 1, if zero then spot separation has no effect
first get a set of refined chains then use this
RemoveChains.m
buildParsedList.m
methodType is either 'spotAngles' (used spot angles to calc prob) or 'noSpotAngles' (does not use spot angles in prob)
build_frame_LIST.m
loop through the points
build_list
if nargin<5
numOfPoints=100;
gaussProbWidth = 13;
minMove = 5;
maxMove = 18;
end
build_frame_LIST_withAngles.m
loop through the points
build_list
if nargin<5
numOfPoints=100;
gaussProbWidth = 13;
minMove = 5;
maxMove = 18;
end
build_frame_LIST_withAnglesRich.m
loop through the points
build_list
if nargin<5
numOfPoints=100;
gaussProbWidth = 13;
minMove = 5;
maxMove = 18;
end
build_list.m
Consider this one spot (eb1Coords(index,1:2)) and visit all other spots in the NEXT frame and start a chain if the transition is probable eb1Coords - the array of xy postions and frame number for every eb1head index - the index into eb1Coord of the start coord
build_list_Rich.m
build_list_withAngles.m
if(nargin < 5)
gaussProbWidth = 13;
minMove = 5;
maxMove = 18;
end
bwL2chL.m
function [out,minchainlen]=bwL2chL(bwLabelList,eb1Coords,siz,parsedListProb,minchainlen) bundle chain information into a data structure that keeps all the relevant data in the same structure essential to maintain the chain ID as it is output per frame. in this structure the first element of Chain and Inds is the start of the chain eb1Coords x,y coordinates are converted in single number indices
chL2bwL.m
function [bwL,frames,probs,eb1Cds]=chL2bwL(chL) convert a chainlist structure (array) to bwLabelList, frames, probabilities and, if given the entire chainlist, reconstruct eb2Coords - actually, this is probably not possible since some spots might not be a part of any chain that has been accepted so far.
chainHistogram.m
checkSpotPairs.m
usage ensure that there refined chains, View spots make data global global data select a chain (right click and note chain number, e.g. 14) de-select chains checkSpotPairs(data,chainnumber,2,0.2)
combineForwardBackward.m
compareChainLists.m
compareHistoChainStrightness.m
compareSpots.m
compareSpots
computeRefine.m
computeRemoveDuplicates.m
distance.m
DISTANCE - computes Euclidean distance matrix
E = distance(A,B)
A - (DxM) matrix
B - (DxN) matrix
Returns:
E - (MxN) Euclidean distances between vectors in A and B
Description :
This fully vectorized (VERY FAST!) m-file computes the
Euclidean distance between two vectors by:
||A-B|| = sqrt ( ||A||^2 + ||B||^2 - 2*A.B )
Example :
A = rand(400,100); B = rand(400,200);
d = distance(A,B);
distance_Bunschoten.m
DISTANCE - computes Euclidean distance matrix
E = distance(A,B)
A - (DxM) matrix
B - (DxN) matrix
Returns:
E - (MxN) Euclidean distances between vectors in A and B
Description :
This fully vectorized (VERY FAST!) m-file computes the
Euclidean distance between two vectors by:
||A-B|| = sqrt ( ||A||^2 + ||B||^2 - 2*A.B )
Example :
A = rand(400,100); B = rand(400,200);
d = distance(A,B);
edit_lineStrightnessPval_threshold.m
getAllChainsInChainListFrame.m
getAllChainsInFrame, given a frame it finds indexes to all the chains present in that frame bwLabelList, a full list of all (N) labelled chains eb1CoordsM, a full list of all vertex coordinates (i.e. points) FrameNumber, image frame of interest NotProcessedLabelList, a list of N flags one per entry in bwLabelList indChainWanted, indexes (into bwLabelList) of chains represented in the frame of interest bwLabelListWanted, list of chains extracted from bwLabelList NotProcessedLabelList, modifed to clear indChainWanted flags J.Andrew Bangham, 2011
getAllChainsInFrame.m
getAllChainsInFrame, given a frame it finds indexes to all the chains present in that frame bwLabelList, a full list of all (N) labelled chains eb1CoordsM, a full list of all vertex coordinates (i.e. points) FrameNumber, image frame of interest NotProcessedLabelList, a list of N flags one per entry in bwLabelList indChainWanted, indexes (into bwLabelList) of chains represented in the frame of interest bwLabelListWanted, list of chains extracted from bwLabelList NotProcessedLabelList, modifed to clear indChainWanted flags J.Andrew Bangham, 2011
getAllFramesInChain.m
getAllFramesInChain, given a list of chains it looks through them to find the range of frame
numbers that could contain chains that intersect with the input chains
The range is MinFrame:MaxFrame
bwLabelList, a full list of all (N) labelled chains
eb1CoordsM, a full list of all vertex coordinates (i.e. points)
MinFrame, frame containing chains of interest
indChainWanted, indexes (into bwLabelList) of chains represented in the frame of interest
crosscheckStartList, list of chains against which chains in a frame of interest (MinFrame) must
be tested to make sure they don't coincide (see refineListFunc2)
MaxFrame, last frame of the range over which we need to analyse for intersecting chains
J.Andrew Bangham, 2011
getEb1XYCord.m
getMinMaxFrame.m
getMinMaxLength.m
getNiceDirNames.m
hideAllChainsExceptClicked.m
histSpotOtsuThresholds.m
histoChainLengths.m
histoChainLengths(chainList,titleString) chainList, from data.ad.chainList titleString, i.e. 'All frame in random order' Usage first load a microtubule project, ensure that it has loaded 'Refine_*' then ... global data histoChainLengths(data)
histoChainStrightness.m
histoSpotProperties.m
histoSpotProperties(data,minChainLength,verbose) histogram spot paramenters for spots <minChainLength and >=minChainLength data, from data minChainLength, default 3 verbose, default false Usage first load a microtubule project, ensure that it has loaded 'Refine_*' then ... global data histoSpotProperties(data,3)
jordiMarkerLocator.m
linefitChain.m
listtags.m
macroM.m
node_add.m
node_constructor.m
parseList.m
plotChain2.m
plotInstanceOfChains.m
figure(1); hold on;
plotOnlySomechains.m
probFunction2.m
probFunction2_withAngles.m
if(nargin < 6)
maxMoveDist = 18;
minMoveDist = 5;
%maxMoveDist = 15;
%minMoveDist = 8;
end
probFunction2_withAngles2.m
function prob = probFunction2_withAngles2(p1, p2, v, sigma,minMoveDist,maxMoveDist,AnglePt2,AnglePt1, EccentricityPt2)
probFunction2_withAngles2JAB.m
function prob = probFunction2_withAngles2JAB
This starts to work on a completely different principle. The idea is ...
1) each spot is represented by a set of values, in regionprops_improved
these are weighted according to the spot intensity
these weighted valuas are now available in spot.wXY
plot column 2 against col. 1 and ...
2) if there is no correlation (i.e. slope = 0) then the correlation coefficient
can be calculated and the probability that the slope is meaningful is given in
spot.prob_slope_significant
and the slope in spot.slope
3) We can see whether spot 1 and spot 2 have the same orientation and whether
the combined slope is significant by concatenating the two spots
wXY2=[spot(1).wXY;spot(2).wXY]
and repeating the steps now in regionprops_improved. e.g.
[r,p]=corrcoef(wXY2);
prob_slope_significant=1-p(1,2);
This will give a
combined slope and probability that it is meaningful.
4) In a similar way we can do (I think) include
how they relate to the S where S is the observed slope between the two spots
The idea is to assume that the spots have the same slope as S so we
subtract this slope from wXY2. If the slopes were the same, then
a plot of wXY2 should show them randomly distributed about 0 (remember we have
subtracted the mean). So the corrcoef yield prob_slope_significant which is low
come to think of it, p (from [r,p]) will be high. Conversely, if S differed from
from the individual spot slopes (actually the combined spot slopes) then p will be low.
If the slope of one spot agreed with S then p will be midway
In other words, we will have progressively removed our estimates from the data
(a) removed two means - making the spots overlap
(b) removed the expected slope - leaving us to see whether the residual values
are correlated. Then we are testing to see if what remains is random (i.e. we have
accounted for everything) or contains a residual slope (so we have not and our
hypothesis is less probable).
probFunction2_withAnglesRichard.m
BUGGED DO NO USE
probFunction2_withAnglesRichard2.m
probFunctionOners.m
probRefineNers.m
probRefineOners.m
probRefineThreers.m
probRefineTwoers.m
probRefineTwoersVer2.m
probRefineTwoersVer3.m
pruneTwoer.m
randSpotXY.m
randomType 1 randomly permutes the xy coords of the spots ransomType 2 generates a random number for xy coords
refineListFunc1.m
function [eb1Coords,bwLabelList,parsedListProb,startFrame,endFrame] = refineListFunc1(...
startList,Ceb1Coords,CparsedListProb,startFrame,endFrame)
refineListFunc2.m
function [eb1Coords,bwLabelList,parsedListProb,startFrame,endFrame] = refineListFunc1(...
startList,Ceb1Coords,CparsedListProb,startFrame,endFrame)
refineListFunc3.m
function [chainList,chainsInFrame] = refineListFunc3(bwLabelList,parsedListProb,eb1Coords,siz)
should remove all chains that are completely contained by another chain
should do the same thing as refineListFunc1 - it is not frame based like refineListFunc2
bwLabelList, Either (for backwards compatibility) each element (indexed by ChainIndex)
is a chain and contains a list of indices (INDICES) into eb1Coords
Or is a structure containing a chainList
parsedListProb, chain probabilities indexed with ChainIndex
eb1Coords,one row per spot, x,y,framenumber, rows indexed by INDICES
siz, size(im) size of the image into which x,y are subscripts
chainList, array of structures, one element per chain - see bwL2chL for structure
chainsInFrame, list of cells indexed by frame number each containing a list of ID's visible in the frame
J. Andrew Bangham, 2011
refineListFunc4.m
function [chainList,chainsInFrame] = refineListFunc4(bwLabelList,parsedListProb,eb1Coords,siz)
NEW IN ver 4 Deletes initial part of chains that overlap another chain
should remove all chains that are completely contained by another chain
should do the same thing as refineListFunc1 - it is not frame based like refineListFunc2
bwLabelList, Either (for backwards compatibility) each element (indexed by ChainIndex)
is a chain and contains a list of indices (INDICES) into eb1Coords
Or is a structure containing a chainList
parsedListProb, chain probabilities indexed with ChainIndex
eb1Coords,one row per spot, x,y,framenumber, rows indexed by INDICES
siz, size(im) size of the image into which x,y are subscripts
chainList, array of structures, one element per chain - see bwL2chL for structure
chainsInFrame, list of cells indexed by frame number each containing a list of ID's visible in the frame
J. Andrew Bangham, 2011
refineListFunc5.m
function [chainList,chainsInFrame] = refineListFunc4(bwLabelList,parsedListProb,eb1Coords,siz)
NEW IN ver 5 replace the arbitrary choice of the i'th chain as the
one to keep as a full length chain - by - the chain with the minimum
bend at the possible break point
NEW IN ver 4 Deletes initial part of chains that overlap another chain
should remove all chains that are completely contained by another chain
should do the same thing as refineListFunc1 - it is not frame based like refineListFunc2
bwLabelList, Either (for backwards compatibility) each element (indexed by ChainIndex)
is a chain and contains a list of indices (INDICES) into eb1Coords
Or is a structure containing a chainList
parsedListProb, chain probabilities indexed with ChainIndex
eb1Coords,one row per spot, x,y,framenumber, rows indexed by INDICES
siz, size(im) size of the image into which x,y are subscripts
chainList, array of structures, one element per chain - see bwL2chL for structure
chainsInFrame, list of cells indexed by frame number each containing a list of ID's visible in the frame
J. Andrew Bangham, 2011
refineListFunc6.m
refineListFunc6Reverse.m
regionprops_improved.m
function result=regionprops_improved(mask,im)
regionprops_improved computes prob_slope_significant, wXY, slope, Orientation
associated with each spot
mask, [0,1] image marking the extent of each spot
im, image showing the image intensity at each spot (WARNING - this
needs to be normalised, because the values are used as scaling factors)
result.slope
result.Orientation
result.prob_slope_significant
result.wXY the weighted differences from the mean x and mean y
where the weights are the im (spot) image values
i.e. white weights the point more heavily
see also
regionprops computes orientation by fitting a first order polynomial
'WeightedCentroid','Orientation','MajorAxisLength',...
'MinorAxisLength','Eccentricity','PixelValues')
renumber_image_files.m
renumber_image_files(projectdirectory) renumbers the image files starting at 0 (used to make it easy to copy a set of images from the middle of a long dataset and check code without having to compute the whole image set)
segmentEB1heads.m
if nargin<5
findcoords=false;
end
segmentEB1heads2.m
if nargin<5
findcoords=false;
end
slider_prob_threshold.m
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleAnalysis\spotMaker
arrangeSpots.m
createImagesFromLineOfSpots.m
createLines.m
genLine.m
genSpot.m
lineOfSpotsToAllspot.m
spotXYToAllspot.m
spotim.m
spotim(im,frame,sievescale1,sievescale2,centile,integralArea1,integralArea2,verbose)
update_image.m
viewChainCoords.m
mark (with a dash) chains where the first (last) coords are the same bwLabelList is either what it says or an array of chL structs
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\MTtbox
Allsetdiff.m
AnnihilateDynOrganelle.m
this plotting stuff should be elsewhere but should not fail on the cluster so leave it here find associated plots
CheckVertsAreValid.m
ClipCell.m
ConsumeReleaseMols.m
function [MT,AvailableTubulin,AvailableBranch,totalAllMTlengths,nextstepAllMTlength]=ConsumeReleaseMols(...
data,MT,...
AvailableTubulin,AvailableBranch,...
totalAllMTlengths,nextstepAllMTlength)
To control the behaviour of microtubules when the amount of tubulin and/or branching factor is limiting
data, MTtbox data structure
MT, a microtubule e.g. data.working.dyn.microtubule.Org(i)
AvailableTubulin, the number of molecules of tubulin available to be consumed
AvailableBranch, the number of molecules of branching factor available to be consumed
totalAllMTlengths, running total of all microtubule lengths in microns
nextstepAllMTlength, the expected length of the next step in microns
CreateDynamicOrganelle.m
FactorProfilePlot.m
function FactorProfilePlot(data,factornames,coordinate,rows,cols,subplotNumber)
Plot the concentration profile of a factor along one axis (the middle of the other two)
on figure(2)
data, the main data structure
factornames i.e. s_a or id_stuff or a cell array of names to be plotted on same axis
e.g. {'s_a','cytoplasm'}
coordinate, 'x','y' or 'z' default 'x'
rows, number of rows in a subplot (default 1)
cols, default 1
subplotNumber, default 1
FigNo, default 2
FillShell.m
fill voxels up to wallthickness with value Label forming a shell
FillStaticOrganelleVolumes.m
GetNSFRegionDefaultProps.m
non-space filling regions co-occupy space, i.e. might occupy a volume within the cytoplasm, cell_membrane or both the regions are specified by an xyz position, the origin or anchor point and a neighbourhood. The neighbourhood is specified by a geometric shape typically a sphere or ellipse, i.e. major axis, minor axis. A pair of positions, pos and neg, on the perimeter of the shape specify the polarity region. For the current Vol, the shape is translated into a set of offsets from the origin. Populations of non-space occupying regions can be placed in space occupying regions A non-space filling region might represent a membrane channel - in which case it would traverse the membrane - overlapping the extracellular space and the cytoplasm. It would have an associated permeability - relating to its diffusion constant A transmembrane pump would be similar, but actively transport material A nucleolus could nucleate microtubules It is possible that these regions have the role of 'edges' in a VVE cell-cell neighbourhood graph. Similarly, spacefilling organelles might combine junction-junction neighbourhoods bi-partite graph
GetOrganelleData.m
get values and put them into the data structure
GetOrganelleDefaultProps.m
Defines and sets all parameters of the cell organelles that can be used in the current model
Some fields, such as FaceColor and Static, cannot be chosen by the user
these are returned by name
Parameters for others can be chosen by the user,
these default values and parameter names are returned through defaultstr,fields
Likewise the list of organelles that are possible and whether they are to be used in the current model or not
GetOrganelleProps.m
props=GetOrganelleProps(data,organelle,property) data, primary data structure organelle, e.g. microtubules, plasma_membrane, etc. property, e.g. size, growthrate, etc.
GrowDynamicOrganelles.m
GrowOneDynamicOrganelle.m
function [data,collisionlist,MT]=GrowOneDynamicOrganelle(data,name,MT)
It will grow an MT (or actin) using the local properties specified by in organelleprops
data, data structure
name, type of dynaMT organelle i.e. microtubule or actin
MT, organelle structure (usually MT for the moment)
organelleprops, copy of the MT properties - which may be default or the same as MT.Props or
may have been modified in some way to according to context
(Actually, so far it is the same as MT.Props
data, data structure for project
MT, modified organelle structure
Input: the following fields are important
MT.Growing if true, it will grow; else it will not
MT.Verts list of vertices
MT.Props.maxZipToMTAngle of MT on hitting another MT
MT.Props.maxAlignToSurfAngle of MT on hitting a membrane
Output:
The rule is supposed to be that
if Growing is false nothing changes
else it remains true unless it collides with and is unable to bend
and align with another MT, plasma-membrane or vacuole membrane
(it may be that the Interaction Function acts on Growing==false
to flag the MT for destruction by the ShrinkOneDynamicOrganelle
function)
flags to control the future of the MT, should be cleared in the
interaction function
MT.Growing if collision at large angle
MT.Verts extended list of vertices
MT.Hit a data structure with pointers to MT's that have been hit
MT.CurrentDirection will change if MT bends
HideBoxRegion.m
function H=HideBoxRegion(data,bottom_right_back,commandstr,bottom_right_back,top_left_front) hide a portion of the cell, by default the back (low z) half data, data structure commandstr, one of 'hide',['show'],'clear' bottom_right_back, by default data.cellprops.cellsize FaceVertexAlphaData, (0,...,1) where 1 is opaque top_left_front, by default [0,0,0] H, handle to the faces of the box
InitialiseModel.m
MTFitGaussians.m
function ObjOut=MTFitGaussians(Y,observedHist,N,axH) Y, list of observed angles N, number of Gaussions to be fitted (each with mean, standard deviation and contribution to mixture) observedHist, observed histogram of data, bins 0:180 degrees axH, axis on which data and results are to be plotted Circular, default false else assume X is periodic ObjOut structure similar to that produced by gmdistribution.fit global axH
MTShowResults.m
function [] = MTShowResults(inputs) To display results from the cluster The results include both png files (which are shown) and stage files Usage cd into project of interest MTShowResults and first click on the experiment parameter file (within the project)
MTStats.m
function data=MTStats(data,varargin)
data, MT data structure
The remaining args are optional and in pairs, e.g.
'Type','Lengths' plot accumulating distributions of MT lengths and density per frame
'Type','Directions', plot accumulating distribution of MT segment directions and directions per frame
'Save','Lengths' histogram of microtubule lengths in each frame [time,numberMTs;time,numberMTs ...]
'Save','Directions' histogram of microtubule segment directions in each frame [12345, time;bin,number;bin,number ...]
If Directions is set then ...
'NumGaus',n, default 2, number of Gaussians to be fitted to the MT segment angle data
'Method','Cyclic' fit Gaussian to augmented data to allow Gaussians to be fitted around the ends
it would be better to have a custom method
'Method','NonCyclic' default, Gaussian mixture fitted to histogram
'Method','AugmentedNonCyclic' Gaussian mixture fitted to augmented histogram to simulate cyclic - but faster
Usage
data=MTStats(data,'Type','Lengths','Type','Directions' );
data=MTStats(data,'Type','Directions','NumGaus',4,'Method','Cyclic');
data=MTStats(data,'Type','Directions','NumGaus',4,'Method','Cyclic','Save','Directions');
PRODUCES a results file in MT_layersAB_3_20130119\runs\default\results
MT_layersAB_3_20130119_default_Directions130121-15-51-50
which after a few steps contains three columns of numbers
the dummy numbers 12345 and 678 allow you to identify the time (in seconds) in the middle
other rows contain: mixture-fraction, mean, standard-deviation
12345 208.000000 678
0.483026 46.117965 16.787653
0.273457 17.826171 10.289600
0.121758 139.249681 30.820787
0.121758 139.249699 30.820780
12345 209.000000 678
0.105868 165.838961 10.096433
0.167310 108.714920 28.797453
0.459578 45.068372 14.944308
0.267243 16.365847 9.543478
12345 210.000000 678
0.450218 46.068017 14.948798
0.285971 16.806099 9.809341
0.162995 109.043207 28.595623
0.100816 165.469058 10.325557
J.Andrew Bangham, 2012
MT_CloseMovie.m
MT_ID2ind.m
function ind=MT_ID2ind(data,ID) data, MT data structure ID, Unique identity of a microtubule ID ind, current index to microtubule ID in data.working.dyn.microtubules.Org
MT_LoadStage.m
data = MT_LoadStage( data, stage, runDirectory )
Load a stage file.
DATA can be any of the following:
A path to a .mat file containing a data structure.
A data structure which has been saved as a project.
A path to a project directory.
STAGE may be any of the following:
Omitted or empty (treated equivalently).
A real number.
A string containing a canonical representation of a real number (as
constructed by makeStageString()).
RUNDIRECTORY may be:
Omitted or empty.
The name of a directory within the "runs" directory within the
project directory specified by DATA.
The different forms of the arguments all have the effect of specifying
a file to load.
When DATA is a path to a .mat file, STAGE and RUNDIRECTORY are ignored
and the specified file is loaded.
When DATA is a data structure or a path to a project directory, if
STAGE is omitted or absent, the initial state of the project is loaded.
If STAGE is present, it specifies a stage file to be found in the
subdirectory of the project specified by RUNDIRECTORY.
If RUNDIRECTORY is absent or empty, the stage directory is "stages"
within the project directory. If RUNDIRECTORY is nonempty, it names a
subdirectory of the "runs" subdirectory of the project directory.
If RUNDIRECTORY is specified, STAGE must also be specified, since run
directories do not contain initial files, only stage files.
All cases of invalid data result in either the original data structure
(if one was supplied) being returned unchanged, or [] returned.
Otherwise, the data structure returned is the one read from the file,
with all necessarily invalid data (such as graphics handles) removed.
MT_SaveStage.m
MT_classifyFields.m
MT_defaultPlotoptions.m
MT_deletePlotWindow.m
MT_get_config_parameter.m
function parameter_string=MT_get_config_parameter(parameter_name,default_string) opens 'MTtbox_config.txt' if it can find it and looks for a string that starts with the parameter_name followed by a space then takes the next string i.e. starting with a space and followed by the end of line or a % character e.g. moviecodec Motion JPEG AVI % this is a string parameter_name is 'moviecodec' and parameter_string will be 'Motion JPEG AVI' If the parameter_name is not found it will add it to the end of 'MTtbox_config.txt' together with the default_string
MT_haveGUI.m
x = MT_haveGUI( data ) Test to see if a GUI is present.
MT_havePlot.m
x = MT_havePlot( data ) Test to see if a plotting window is present.
MT_haveProject.m
x = MT_haveProject( data ) Test to see if a project is present.
MT_makePlotWindow.m
MT_plotoptions.m
MT_reshapeCell.m
data = MT_reshapeCell( data, ... )
Change the shape and dimensions of the cell and restart the simulation.
When the DATA argument is present, default values for all options are
the values contained there. Otherwise, default values are as described
below.
Options:
'shape': Allowed values are 'Rect' (the default), 'Sphere', or 'Disc'.
'vacuole': a triple [X,Y,Z] or a single number X, which will be
treated as the triple [X,X,X]. The dimensions in microns
of the vacuole, if any. The vacuole is always centred in
the cytoplasm. To specify that there is no vacuole, pass
the number zero. The default is no vacuole.
'dimensions': a triple [X,Y,Z] or a single number X, which will be
treated as the triple [X,X,X]. The dimensions in microns
of the cell. There is no default for this: when creating a
new cell from scratch, its dimensions must be specified.
'xvoxels': A single integer, the number of voxels along the X
dimension of the cell. The number of voxels in the other
dimensions will be proportional to this.
'yvoxels', 'zvoxels': Similar to xvoxels. Only one of these three
options can be given. If more than one is given, the one
implying the smallest total number of voxels will be used.
'voxels': A three-element array, equivalent to specifying all of
xvoxels, yvoxels, and zvoxels. A single integer can be
given, implying that the three numbers are equal.
'numvoxels': A single integer, specifying the total number of voxels in
the cell. The actual number of voxels will be the largest
value of X*Y*Z less than or equal to this number,
consistent with the voxel array being X by Y by Z.
If more than one of 'xvoxels', 'yvoxels', 'zvoxels', or 'numvoxels' is
specified, that one will be used which implies the smallest total
number of voxels. At least one of these options must be given when
creating a cell from scratch.
'sheetmodel': True or false (the default). If true, microtubules will be
constrained to a flat sheet vertically bisecting the cell,
with vertical coordinate rounded to the height of a middle
layer of voxels.
'timestep': A real number, the time step of the simulation (default 1).
'nuclspont': The probability per cubic micron per unit time of the
spontaneous nucleation of a microtubule.
'nuclonMT': The probability per micron per unit time of the
branching of a new microtubule from another microtubule.
MT_save_project_as.m
[data,ok] = MT_save_project_as( data, projectname, parentdir, ... )
Save the project to a project directory.
PROJECTNAME is the name of the project folder. This must not be a full
path name, just the base name of the folder itself. It will be looked
for in the folder PROJECTDIR, if specified, otherwise in the parent
directory of DATA, if any, otherwise the current directory.
If PROJECTNAME is not specified or empty, the user will be prompted for a
name using the standard file dialog.
The project directory will be created if it does not exist.
If the project is being saved into its own project directory:
If it is in the initial state (i.e. no simulation steps have been
performed, and the initialisation function has not been called) then
it is saved into the file PROJECTNAME.mat.
If it is in a later state, it will be saved to PROJECTNAME_Snnnn.mat,
where nnnn is the current simulation time as a floating point
number with the decimal point replaced by a 'd'.
If the project is being saved into a new directory:
The current state will be saved as an initial state or a later
stage file as above.
If the current state is not the initial state, then the initial
state will be copied across. Furthermore, the initial state of the
new project will be loaded.
The interaction function and notes file will be copied, if they
exist. If the notes file exists, the new notes file will also be
opened in the editor.
Stage files, movies, and snapshots are NOT copied across.
If for any reason the project cannot be saved, OK will be false.
Options:
new: If true, the mesh will be saved as the initial state of a
project, even if it is not the initial state of the current
simulation. The default is false.
strip: If true, as many fields as possible of the data will be
deleted before saving. They will be reconstructed as far as
possible when the mesh is loaded. The only information that
is lost is the residual strains and effective growth tensor
from the last iteration. The default is false.
Equivalent GUI operation: the "Save As..." button prompts for a
directory to save a new project to; the "Save" button saves the current
state to its own project directory. The "strip" option can be toggled
with the "Misc/Strip Saved Meshes" menu command.
Topics: Project management.
MT_setRunName.m
data = MT_setRunName( data ) Set the name of the current run. The name given will be canonicalised so as to force it to be a legal directory name. If the name is empty then it will be replaced by 'default'.
MT_set_config_parameter.m
function data = MT_set_config_parameter( data, parameter_name, default_string ) opens 'MTtbox_config.txt' if it can find it and looks for a string that starts with the parameter_name followed by a space then replaces the next string by the default_string i.e. starting with a space and followed by the end of line or a % character e.g. moviecodec Motion JPEG AVI % this is a string parameter_name is 'moviecodec' and parameter_string will be 'Motion JPEG AVI' If the parameter_name is not found it will add it to the end of 'MTtbox_config.txt' together with the default_string
MT_updateDataFromGUI.m
MT_updateGUIFromData.m
MT_wrap.m
function data=MT_wrap(data,operation,organelle) for use in the interaction function. Allows microtubules to wrap from one side to another by creating a new MT on the other side that grows in the same direction data, MTtbox structure operation, at startup time set to 'STARTUP' else 'RUN' organelle, default 'cytoplasm) usage if data.iterations==0 % setup wrapping data=MT_wrap(data,'setup'); else % Wrap where needed by creating new MTs that form the wrap data=MT_wrap(data,'run'); end
MTlengthMicrons.m
function [MTlength,NewMT]=MTlengthMicrons(data,MT) data, MTtbox data structure MT, microtubule e.g. from data.working.dyn.microtubule.Org(i) MTlength, in microns (the vertices are spaced in voxels ?) NewMT, logical 1 if MT is thought to be new else 0
MTtbox.m
MTtboxAddFactor.m
data = MTtboxAddFactor( data, newnames ) NEWNAMES is a cell array of names of new factors to be added. they are checked to see if they exist already; those that do are ignored.
MTtboxCommand.m
function [argument_list,subfileArgList]=MTtboxCommand(varargin)
For running microtubule models in batch mode. Results are filed in a
subdirectory
ProjectName:runs:experimentname:meshes stores full microtubule .mat files
At the end of each stage/step the data structure is stored in a separate file.
In addition, the command line used to invoke MTtboxCommand
and a copy of the interaction function are saved in the experimentname directory.
The data structures can be viewed using MTtbox software
When running jobs on the cluster, MTtboxCommand will automatically
log the fact with a program called ClusterControl.
To run on the cluster you must have
1) Your (UEA) Cluster username
2) Your (UEA) Cluster username Password
3) The (UEA) Cluster name, e.g. eslogin.uea.ac.uk
4) Path to your filespace within the cluster (excluding your
name)
(e.g 'gpfs/tmpscratch01/sys/')
(or 'gpfs/sys/')
and the following programs installed on your computer
4) WinSCP
5) Putty
6) pscp
7) plink
these can be installed on a Mac from the Terminal using MacPorts (e.g. sudo port install putty)
There is an option to output a set of shell scripts (.sh files) that
enable the results to be computed on a cluster in parallel.
This is invoked by the 'Use','Cluster', command pair.
Usage, all argument pairs are optional
MTtboxCommand(...
'State','RunNow',... % status of command, options are:
% default is 'RunNow', i.e. when 'State' is not used then
% system is run on the current computer
%
% The following only apply to running on the cluster
% 'Run' create and run a single command
%
% 'Begin' to begin assembling a batch of commands
% 'Add' to add to the existing batch
% 'Start' to add to and then run batch of commands
%
'Use','Cluster' % use the cluster if it is accessible
% default is not to use the cluster
'Name','IMotif2a',... % project to be run
'Path', pwd,... % present working directory
'DryRun', false,... % If true, no actual invocation of MTtbox
% will be made. Instead the commands that
% would have been issued are printed to the
% console.
% this command is used to change dt
Using time
'Stages',[80,120,...] % default, output at every iteration
% list of stages (in hours) that are to be
% output.
% Overrides Stepsize.
% Overrides total_time, i.e. total_time=max(stages)
% stage filenumbers are time - consistent
% GFtbox
Using steps
'N_steps', 20,... % number of steps to be run
'Stepsize',1,... % interval between steps that are recorded
% overridden by Stages
% defaut 1
'param',[indices] % it is possible to automatically
%create set of experiments that systematically vary parameters
%of the model. These have to be setup inside the interaction
%function. e.g. the parameter called 'param' is set up with
%m.userdata.ranges.param.range=[0, 1.2, 5, 10]
%m.userdata.ranges.param.index=3; % this sets the default, i.e.
%param=5. By setting an invalid index using
%on the MTtboxCommand command line, i.e. 10
in this case, each value of the parameter
will be used. If two range parameters are
set then the combinations will be run as
separate jobs, i.e. if there were 4 and 5
alternatives respectively, 20 experiments
would be created.
%Sensitivity testing
%m.userdata.ranges.sensitivity.range
%m.userdata.ranges.sensitivity.index
this is a reserved userdatat ranges field
that is recognised by MTtboxCommand. In
To perform a sensitivity test, there must
be set of obj files in a directory called
objs. One obj per time step.
It is differences between the test sensitivity values
and these obj files that will be computed.
that will
'ExpID',name, % not for general use. Used internally by MTtboxCommand
% to label experiments as they are run on
% the cluster
e.g.
Run on personal computer
MTtboxCommand('path','D:\ab\Matlab stuff\Microtubule','Name','MT_Demo5_20120807','N_steps',[5,15,25]);
MTtboxCommand('path','D:\ab\Matlab stuff\Microtubule','Name','MT_Demo5_20120807','N_steps',[5,15,25],'spont_nucleation',[1,3]);
Run on cluster, exploring two range parameters
MTtboxCommand('Name','MT_Demo4_20120718','N_steps',[5,15,25],'spont_nucleation',1);
MTtboxCommand('Name','MT_Demo4_20120718','N_steps',[5,15,25],'spont_nucleation',1,'growth',1,'Use','Cluster');
Run on cluster, exploring the effect of different dt and number of
vertices
MTtboxCommand('State','Begin','Name','NewFig4','dt',1.0,'Stages',[2,5,7],'Use','Cluster');
MTtboxCommand('State','Add','Name','NewFig4','dt',0.1,'Stages',[2,5,7],'Use','Cluster');
MTtboxCommand('State','Add','Name','NewFig4','dt',1.0,'Subdiv',true,Stages',[2,5,7],'Use','Cluster');
MTtboxCommand('State','Start','Name','NewFig4','dt',0.1,'Subdiv',true,'Stages',[2,5,7],'Use','Cluster');
Try a range of dts, run for two separate models, for all combinations
of the specified mutations
MTtboxCommand('State','Start','Name','NewFig4','dt',[0.1 0.5 1] ,'Subdiv',true,'Stages',[2,5,7],'Use','Cluster','modelname',[1 2],'Mut_List',{'mutation1','mutation1'});
J.Andrew Bangham, 2008
Jacob Newman, 2011
if isunix
% then assume it is running on the cluster and the paths are to be
% setup relative to the current directory
pathnames=fullfile(pwd,'DArT_Toolshed');
addpath(genpath(pathnames));
end
MTtboxCommandGrace.m
function [argument_list,subfileArgList]=MTtboxCommand(varargin)
For running microtubule models in batch mode. Results are filed in a
subdirectory
ProjectName:runs:experimentname:meshes stores full microtubule .mat files
At the end of each stage/step the data structure is stored in a separate file.
In addition, the command line used to invoke MTtboxCommand
and a copy of the interaction function are saved in the experimentname directory.
The data structures can be viewed using MTtbox software
When running jobs on the cluster, MTtboxCommand will automatically
log the fact with a program called ClusterControl.
To run on the cluster you must have
1) Your (UEA) Cluster username
2) Your (UEA) Cluster username Password
3) The (UEA) Cluster name, e.g. grace.uea.ac.uk
4) Path to your filespace within the cluster (excluding your
name)
(e.g 'gpfs/tmpscratch01/sys/')
(or 'gpfs/sys/')
and the following programs installed on your computer
4) WinSCP
5) Putty
6) pscp
7) plink
these can be installed on a Mac from the Terminal using MacPorts (e.g. sudo port install putty)
There is an option to output a set of shell scripts (.sh files) that
enable the results to be computed on a cluster in parallel.
This is invoked by the 'Use','Cluster', command pair.
Usage, all argument pairs are optional
MTtboxCommand(...
'State','RunNow',... % status of command, options are:
% default is 'RunNow', i.e. when 'State' is not used then
% system is run on the current computer
%
% The following only apply to running on the cluster
% 'Run' create and run a single command
%
% 'Begin' to begin assembling a batch of commands
% 'Add' to add to the existing batch
% 'Start' to add to and then run batch of commands
%
'Use','Cluster' % use the cluster if it is accessible
% default is not to use the cluster
'Name','IMotif2a',... % project to be run
'Path', pwd,... % present working directory
'DryRun', false,... % If true, no actual invocation of MTtbox
% will be made. Instead the commands that
% would have been issued are printed to the
% console.
% this command is used to change dt
Using time
'Stages',[80,120,...] % default, output at every iteration
% list of stages (in hours) that are to be
% output.
% Overrides Stepsize.
% Overrides total_time, i.e. total_time=max(stages)
% stage filenumbers are time - consistent
% GFtbox
Using steps
'N_steps', 20,... % number of steps to be run
'Stepsize',1,... % interval between steps that are recorded
% overridden by Stages
% defaut 1
'param',[indices] % it is possible to automatically
%create set of experiments that systematically vary parameters
%of the model. These have to be setup inside the interaction
%function. e.g. the parameter called 'param' is set up with
%m.userdata.ranges.param.range=[0, 1.2, 5, 10]
%m.userdata.ranges.param.index=3; % this sets the default, i.e.
%param=5. By setting an invalid index using
%on the MTtboxCommand command line, i.e. 10
in this case, each value of the parameter
will be used. If two range parameters are
set then the combinations will be run as
separate jobs, i.e. if there were 4 and 5
alternatives respectively, 20 experiments
would be created.
%Sensitivity testing
%m.userdata.ranges.sensitivity.range
%m.userdata.ranges.sensitivity.index
this is a reserved userdatat ranges field
that is recognised by MTtboxCommand. In
To perform a sensitivity test, there must
be set of obj files in a directory called
objs. One obj per time step.
It is differences between the test sensitivity values
and these obj files that will be computed.
that will
'ExpID',name, % not for general use. Used internally by MTtboxCommand
% to label experiments as they are run on
% the cluster
e.g.
Run on personal computer
MTtboxCommand('path','D:\ab\Matlab stuff\Microtubule','Name','MT_Demo5_20120807','N_steps',[5,15,25]);
MTtboxCommand('path','D:\ab\Matlab stuff\Microtubule','Name','MT_Demo5_20120807','N_steps',[5,15,25],'spont_nucleation',[1,3]);
MTtboxDeleteFactor.m
data = MTtboxDeleteFactor( data, selectednames ) Delete the named factors. Names that do not exist are ignored.
MTtboxDir.m
dirname = MTtboxDir() Find the Microtubule Toolbox directory.
MTtboxQuit.m
MTtboxRunSilent.m
runs SilentGFtbox having ensured that paths to the DArT_Toolbox are present.
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\MTtbox\OLD
OrgID2Index.m
ResetDynamicPlotPropsH.m
ResetFactorPropsH.m
ResetStaticPlotPropsH.m
ResetWorkingStructure.m
SetUnscaleMarkers.m
SetUnscaleMarkers([property,value])
Scale markers in proportion to x-axis scale rather than in points.
When active SetUnscaleMarkers stores data in the axes.userdata and redirects the
resize callback of the axes parent figure.
properties and values
'State','on' the size of specified markers is in proportion to x axis (instead of in points)
'off' default, markers are specified in points - as normal in Matlab
'Axes',handle (default: current axes from gca)
'Size',value (default: 0.1) fraction of x-axis maxscale-minscale
'Tag','name' (default all markers) name of line containing markers to be scaled
Example usage:
linemarkertag='ThisOne';
a=0:10;
plot(a,a,'.b','markersize',10,'tag',linemarkertag);
handle=gca;
SetUnscaleMarkers('State','on','Axes',handle,'Size',0.1,'Tag',linemarkertag);
% now drag figure window to resize according to length of x axis
% and to return things to normal
SetUnscaleMarkers('State','off');
J. Andrew Bangham, 2011
ShrinkDynamicOrganelle.m
function [data]=ShrinkDynamicOrganelle(data) Reduce the length of all the dynamic organelle (microtubule) data, MTtbox data structure
ShrinkOneDynamicOrganelle.m
function [data,i_MT]=ShrinkOneDynamicOrganelle(data,name,i_MT) I'm not sure why an index into the MT of interest is passed rather than the MT itself - but there was a reason at some stage. Always shrinks from the tail end - irrespective of speed - but catastrophes should work from the front end - likewise rescues - but not yet implemented % where MT=data.working.dyn.(name).Org(i_MT) the idea is that if MT.Alive==false then the MT will be deleted else it will shrink from the - end until it is deleted Input: the following fields are important MT.Alive MT.Verts MT.Shrinking MT.ShrinkingHead Output: the following fields are important MT.Verts MT.CurrentDirection
SphereSubscripts.m
r is radius i,j,k indices into the sphere
SuffixToStageTime.m
function time=SuffixToStageTime(name)
TestInsertMTintoVol.m
mt, microtubule or other growing/shrinking organelle data, main data structure NameRegionTofill, name of volume in which the organelle is growing, usually 'cytoplasm' DynamicOrg, name of growing, nucleating or shrinking organelle, e.g. microtubule collision.mtHitIDs List of all microtubules this one has hit. collision.staticorgHitIDs List of static organelles it has hit, other than the one it swims in. collision.acollision True if either of these is nonempty. J. Andrew Bangham, 2011
ViewVols.m
This is a no-op.
backOffLineCollision.m
[p2new,remainingdistance] = backOffLineCollision( p1, p2, o1, o2, d ) The arguments define two line segments, one from p1 to p2, one from o1 to o2. d is a distance. p2 is assumed to be closer than d to the line joining o1 and o2. This procedure calculates a point p2new which is at a distance d from the line through o1o2 and has the same projection onto that line as p2. remainingdistance is the amount by which the distance from p1 to p2new is less than the distance from p1 to p2. Negative values (which should not happen) are replaced by 0.
bestFitPlaneOneSide.m
[p1,n] = bestFitPlaneOneSide( vxs, pt ) Calculate a best-fit plane to the set of vertexes vxs, and return its unit normal vector as N. Consider a plane parallel to the best-fit plane, such that (1) all of the points in VXS lie on one side of that plane, (2) PT is at least as close to that plane as the centroid of VXS, and (3) the plane is as close to the centroid as possible. P! is the intersection of that plane with the line through PTZ parallel to N.
calculateEllipse.m
# This functions returns points to draw an ellipse # # @param x X coordinate # @param y Y coordinate # @param a Semimajor axis # @param b Semiminor axis # @param angle Angle of the ellipse (in degrees) #
capsuleProximity.m
[isnear,distance,approaching,p,q] = capsuleProximity( p01, q01, dmin ) Return true if the line segments specified by p01 and q01 are closer than dmin. p01 and q01 are exactly as in lineLineDistance().
cellAge.m
function t = cellAge( data ) t, age in seconds
checkMTvalid.m
checkMTvalid( mt ) Perform validity checks on a microtubule, for debugging purposes. This checks that consecutive vertexes are distinct. When they aren't, bad things happen.
checkbox_clipped.m
chooseDirection.m
direction=chooseDirection(n) Generate N random unit vectors in 3D, uniformly distributed on the unit sphere. N defaults to 1. The result is an N*3 matrix of row vectors.
chooseEndPosition.m
chooseEndPositionSheetModel.m
End_polar=[ rand*2*pi, rand*2*pi, Radius]; % polar relative to StartXYZ
chooseStartPosition.m
function xyz=chooseStartPosition(data,regionsToFill)
data, main data structure of MTtbox
ind, indexes to region to be filled (if default then it will use cytoplasm)
regionsToFill, [default cytoplasm] list of regions e.g. {'cytoplasm','plasma_membrane'}
xyz, coordinates of position in data.cellprops.Vol
J.Andrew Bangham 2011
clipoutregionMovie.m
function outputMovie = clipoutregionMovie( filename1, filename2 ) narrows the gap between the two movies J.Andrew Bangham, 2013
compactMTData.m
mtdata = compactMTData( mtdata ) Eliminate all fields of mtdata that can be reconstructed from the remainder.
createCellShape.m
function data=createCellShape(data) Requires data.cellprops.shape data.cellprops.cellsize Returns data.cellprops.Vol where -1 labels non_cell region and 0 labels the cell region J.Andrew Bangham, 2012
create_cell_organelles_interactively.m
function data=create_cell_organelles_interactively(data) populate data.organelleprops i.e. data.cell_wall: [1x1 struct] data.plasma_membrane: [1x1 struct] data.cytoplasm: [1x1 struct] data.nucleus: [1x1 struct] data.microtubules: [1x1 struct] data.actin: [1x1 struct] data.vacuole: [1x1 struct]
create_cell_properties_interactively.m
function [data,cancelled]=create_cell_properties_interactively(data) populate data.cellprops e.g. data.shape: 'Rect:1:1:1' data.cellsize: [25 25 25] data.Smooth: 'None'
deleteGraphicsHandleAndChildren.m
deleteWindow.m
diffuse3D.m
x = diffuse( x, k )
X is a 3D array of concentrations defined on a spatially regular grid of
any size. K is either a single number or a 3D array of diffusion
coefficients on the same grid.
The concentration of x on the bounding surfaces is assumed to be clamped
at whatever value it has initially.
For the calculation to be valid, the relative change in concentration at
every point should be below 10% on each iteration step.
To create an impermeable barrier between two diffusion regions, their
common boundary must be defined by a set of nodes with diffusion constant
zero, such that every path from the interior of one region to the
interior of the other, passing always from a node to one of its
orthogonal neighbours, passes along a consecutive pair of nodes in the
barrier.
To make the boundary surface of the mesh impermeable, make the diffusion
constant zero on the outermost two layers of vertices.
All of the following computation schemes are based on the idea of
replacing each value by a weighted sum of it and its orthogonal
neighbours' values.
When k is spatially constant the following simple scheme is correct:
x' = (1-6*k)*x + k(sum of neighbouring values of x)
If k varies from place to place, it is not correct to simply replace k in
the above by the value of k at the point, because this will violate
conservation of material. Neither is the following scheme correct:
x' = (1-6*k)*x +
sum of( neighbouring value of k * neighbouring value of x )
This satisfies conservation of material but violates the principle that
if the concentration of x is spatially constant, there can be no net flow
in any direction. There will be a fictitious flow down the gradient of
diffusion coefficient, proportional to its spatial rate of change and to
the square of the mesh step size.
The scheme that is implemented here satisfies both conditions. It
calculates the flow from a point A to a neighbouring point B as equal to
(xA - xB)(kA + kB)/2. This amount is added to B and subtracted from A.
The relationship between k, the diffusion constant D of the underlying
continuous system, the time step dt, and the mesh step dx is
k = (D dt)/(4 dx^2).
discreteCapsule.m
vertexes = discreteCapsule( startPt, endPt ) Imagine a 3D grid of points at integer coordinates. STARTPT and ENDPT are points with not necessarily integer coordinates. This routine returns a list, in increasing order, of the indexes of all grid points that lie within RADIUS of the straight line segment from STARTPT to ENDPT. STARTPT and ENDPT can validly be the same point.
dispMTprops.m
function displays MT properties dispMTprops(ID)
displayMT.m
function [inds,IDs]=displayMT(data,type,num)
data,
type, either 'Index' requires num
or 'ID' requires num
or 'All' (DEFAULT)
or 'MT' i.e. all bound to other MT's
or 'PL' i.e. all bound to plasma-membrane
or 'Prop' requires num to be the name of a property
num, one or more indexes or ID's
if no arguments on the left hand side then display all results
else do not display
inds, indexes of all found
IDs, ID's of all found
doInteraction.m
doStep.m
function data = doStep(data) Step of the MTtbox model. If called from the MTtbox then it displays results etc.(UsingGUI=true) else it simply updates data end data, MTtbox data structure
edit_clip_0.m
if nargin<2 || ~isfield(data.cellprops,'slicenumber')
edit_clip_2.m
establishAxes.m
expandMTData.m
mtdata = expandMTData( mtdata ) Restore all fields of mtdata that were removed by compactMTData( mtdata ).
findBestDeflection.m
[newdir,deflectionAngle] = findBestDeflection( dir, impactVectors, maxDeflection ) Find a direction NEWDIR which minimises the angle between it and DIR, subject to its angle with each vector in impactVectors being at least pi/2. DIR is a row vector and IMPACTVECTORS is a matrix of row vectors. NEWDIR is returned as a row vector. If there is no solution, NEWDIR and DEFLECTIONANGLE are returned as empty. If there are no impactVectors, then NEWDIR is DIR and DEFLECTIONANGLE is 0. Requires the Optimisation Toolbox, for the procedure quadprog.
findBestDisplacement.m
[displacementVec,displacementSize,ok] = findBestDisplacement( penetrations ) A sphere at the origin penetrates several planes by amounts and in directions specified by PENETRATIONS. These should be imagined to be small compared with the radius of the sphere, although the calculation is correct regardless of their sizes. Each penetration is a vector, along a radius of the sphere perpendicular to one of the planes, and proceeding from the intersection of the radius and that plane to the intersection of the radius and the sphere. This procedure calculates the vector of shortest length such that, if the sphere is displaced by this vector, it no longer intersects any of the planes. If no such vector exists, the zero vector is returned. It also returns the length of the displacement vector. In this case, OK will be false, otherwise true. PENETRATIONS is an array of row vectors, and DISPLACEMENTVEC is a row vector. If PENETRATIONS is empty, then DISPLACEMENTVEC is the zero vector, DISPLACEMENTSIZE is zero, and OK is true
findBestRetraction.m
[newdir,frac,ok] = findBestRetraction( dir, vecs ) DIR is a vector representing one step in the growth of a microtubule. VECS is the set of impact vectors resulting from collisions during that step. NEWDIR is the maximum step in the original direction that would avoid all of those collisions. FRAC is the ratio of the length of NEWDIR to DIR. OK is true if FRAC is at least 1e-3 times the length of DIR. Any vectors in VECS with squared length less than 1e-8 will be ignored. If there are no other vectors then NEWDIR will equal DIR, FRAC will be 1, and OK will be true.
findMTtboxFile.m
findNonMember.m
n = findNonMember( v ) Find the smallest positive integer not in the given list of positive integers.
findRunDir.m
findRunSubDir.m
gauss_distribution.m
getClipSliceNumber.m
function slicenumber=getClipSliceNumber(data,pc) data, MTtbox data structure pc, clip position as percentage along the z- axis
getClipSliceNumber2.m
function slicenumber=getClipSliceNumber2(data,pc) data, MTtbox data structure pc, clip position as percentage along the x- axis
getDiffusionK.m
function diffk=getDiffusionK(data,factorname) Convert the data structure created by setupDiffusion into a 3D Vol of diffusion coefficients factorname can be a string or an index. If the diffusion constants are all zero, the empty array is returned. J. Andrew Bangham, 2011
getFactorFromRole.m
[factorIndex,factorName] = getFactorFromRole( data, role ) Return the index and the name of the factor occupying the given role. If there is no such role or no such factor, the index is zero and the name is empty.
getProjectDir.m
getStaticOrganelleColours.m
goToMTProjectDir.m
gomt.m
hasHit.m
function [hit,hitat,hitwhen]=hasHit('what',MT)
what, 'MT' (default) or 'STATIC' (any of the following) or 'PLM' or 'VAC' or 'WLL' or 'NUC'
MT, microtubule structure
hitmt, false if nothing has ever been hit by microtubule MT
of ID of microtubule that has been hit
or label of static organelle that has been hit
hitat, x,y,z coordinates of collision
hitwhen, time of collision
To cancel all previous hits
MT.Hit=struct('hitmt',[],'hitstatic',[],'hitat',[],'hitwhen',[]);
Usage
if hasHit('MT',MT)
then do something
end
hasHit('Static',MT);
hasJustHit.m
function hit=hasJustHit(what,MT,data)
what, 'MT' (default)
or 'STATIC' (any of the following) or 'PLM' or 'VAC' or 'WLL' or 'NUC'
or 'ANY' either MT or STATIC
MT, microtubule structure
where MT.Userdata.type is set to e.g. 1 or 2 or 'A' or 'B' designating say, cortical or subcortical MT
then you also require
data, MTtbox data structure
hit, false if nothing has JUST been hit by microtubule MT
of ID of microtubule that has been hit
or label of static organelle that has been hit
Usage
if hasJustHit('MT',MT)
then do something
end
where there are two types of MT,
MT.Userdata.type=1; % set according MT type (cortical, sub-cortical)
MT.Userdata.type=2;
if hasJustHit('MT',MT,data)
...
to test for collision between identical types
see also
hasHit('Static',MT);
hideAllMTsExceptClicked.m
insertNSFRegion.m
non-space filling regions (NSF) co-occupy space, i.e. might occupy a volume within the cytoplasm, cell_membrane or both the regions are specified by an xyz position, the origin or anchor point and a neighbourhood. The neighbourhood is specified by a geometric shape typically a sphere or ellipse, i.e. major axis, minor axis. A pair of positions, pos and neg, on the perimeter of the shape specify the polarity region. For the current Vol, the shape is translated into a set of offsets from the origin. Populations of non-space occupying regions can be placed in space occupying regions A non-space filling region might represent a membrane channel - in which case it would traverse the membrane - overlapping the extracellular space and the cytoplasm. It would have an associated permeability - relating to its diffusion constant A transmembrane pump would be similar, but actively transport material A nucleolus could nucleate microtubules It is possible that these regions have the role of 'edges' in a VVE cell-cell neighbourhood graph. Similarly, spacefilling organelles might combine junction-junction neighbourhoods bi-partite graph
isCheckedMenuByTag.m
isInCytoplasm.m
isinside = isInCytoplasm( data, pos ) Determine whether the given point is in the cytoplasm, by rounding it and looking it up in data.cellprops.Vol.
isoCapsCorrect.m
fv = isosurfaceCorrect( vol, value ) Workaround for Matlab's perverse implementation of isosurface, which arbitrarily swaps the coordinates X and Y in the result.
isocapPatchStaticOrganelles.m
isonormalsCorrect.m
isosurfaceCell.m
setup outside of volume for isosurface set(data.plotprops.AxesH,'color','w');
isosurfaceCorrect.m
fv = isosurfaceCorrect( vol, value ) Workaround for Matlab's perverse implementation of isosurface, which arbitrarily swaps the coordinates X and Y in the result.
listOfTags.m
listbox_experimentlist.m
function data=listbox_experimentlist(data) Use the Experiment name listbox to select and load an experiment
listbox_factorlist.m
loadProject.m
--- help for vdspdebug/loadProject ---
LOADPROJECT Load the program file.
Overloaded methods:
explorer.loadProject
load_experiment_stage.m
localImDilate.m
makeFactorName.m
Convert s to upper case. Replace all strings of non-word characters by single underscores. If the result does not begin with a letter, prefix 'X_'.
makeRunDir.m
makeRunSubDir.m
makeStageSuffix.m
menu_printsnapshot.m
menu_refresh_plot.m
menu_replot.m
menu_snapshot.m
menu_start_movie_recording.m
microtubuleCollision.m
[mts,mtids,ds,angles,mtAngles,impactVectors,newIgnoreMTIDs] = microtubuleCollision( data, mtID, p01 ) mtID is the ID of a microtubule. p01 is its last two vertices, or its last vertex if it has only one. mts is a list of the indexes, and mtids a list of the IDs, of all the microtubules it collides with. ds is a list of the distances. angles is a list of the contact angles. impactVectors is a list of the vectors from the centre of the end of the microtubule to each of the contact points with other microtubules.
mtCollisionDir.m
[newDir,collisiontype] = mtCollisionDir( previousDir, otherDir, maxAngle ) A microtubule travelling in direction previousDir collides with a microtubule travelling in the direction otherDir. This procedure calculates the resulting direction of the microtubule. This will be parallel or antiparallel to otherDir, provided the angle between otherDir and previousDir is below maxAngle, otherwise it will be previousDir. previousDir should be a unit vector. otherDir may have any nonzero length. newDir will be a unit vector. collisiontype is 1 if newDir is parallel to otherDir, -1 if antiparallel, and 0 if newDir is previousDir.
mtSETMTprops.m
function data=mtSETprops(data,varargin)
data, MTtbox data structure
remaining arguments in pairs ('fieldname',value)
where fieldnames are:
thicknessMicrons: 0.025000
outerThicknessRatio: 1 % tip 'magnetic range' centred on and 1*diameter of MT tip, could be e.g. 4
minvox: 1.0000e-04
growthrate: 0.1000 % microns per sec positive end
shrinkrate: 0.0300 % microns per sec negative end
catastropherate: 0.5000 % transition rate positive end
maxAlignToSurfAngle: 40
maxZipToMTAngle: 50
maxSpawnAngle: 50
maxAge: 0
nuclspont: 0.0012 % transition rate
nuclonMT: 1.2000e-04 % transition rate
probCatastropheWhenHit: 0.3000 % transition rate positive end
rescuerate: 0.0 % transition rate from paused to growing
probPauseOnCollision: 0.7000 % transition rate positive end
probSpontaneousCatastrophe: 0.0300 % transition rate positive end
backwardBranching: 0.5000 (50% forwards and 50% backwards)
parallelspawnprob: []
wraparound: 0
FaceColor: [0 0 1]
FaceAlpha: 0.4000
Label: -6
isLayer: 0
Static: 0
InUse: 1
bendpriority: 'membrane' (default), 'mt' (microtubule),'max' (max of the two), 'min'
shrinkheadrate: 0.3000 ( % microns per sec positive end)
mtSETindividualMTprops.m
function data=mtSETindividualMTprops(data,varargin)
data, MTtbox data structure
ID, identity of microtubule(s)
remaining arguments in pairs ('fieldname',value)
where fieldnames are:
Type
PauseDuration
TimeNucleated
ID
parentID
Alive: logical
Growing: logical
Shrinking: logical
ShrinkingHead: false (default)see Props.shrinkheadrate
Catastrophe: logical
Verts
CurrentDirection
Props: structure see below
AgeFormed
BoundPLM: logical
BoundMic: logical
BoundVac: logical
BoundWll: logical
plothandles
plotprops
HitMe: structure
Hit: structure
Userdata
Wrapped: logical
%Props also see help on mtSETMTprops
thicknessMicrons: 0.5000
minvox: 1.0000e-04
growthrate: 0.1000
shrinkrate: 0.0300
catastropherate: 0.5000
maxAlignToSurfAngle: 40
maxZipToMTAngle: 50
maxSpawnAngle: 50
maxAge: 0
nuclspont: 0.0012
nuclonMT: 1.2000e-04
probCatastropheWhenHit: 0.3000
probPauseOnCollision: 0.7000
probSpontaneousCatastrophe: 0.0300
backwardBranching: 0.5000
parallelspawnprob: []
wraparound: 0
FaceColor: [0 0 1]
FaceAlpha: 0.4000
Label: -6
isLayer: 0
Static: 0
InUse: 1
bendpriority: 'membrane'
shrinkheadrate: 0.3000
multiMovie.m
function outputMovie = multiMovie( filename1, filename2 ) Combines two movies into one with images side by side If one movie is longer than the other, the longer one is evenly subsampled to give the same number of frames as the shorter the width of the final movie is 1024 pixels and the height varies depending on the size of the input movies Images are scaled such that the aspect ratios of both are maintained. The output file name is a concatenation of the input filenames J.Andrew Bangham, 2013
non_interactive_MTtbox_B.m
nucleateDyn.m
function [data,nucleated]=nucleateDyn(data,NameRegionTofill,...
NucleatingOrganelle,forcedStartPosition,NewDirection,parentID,N)
Usage:
to create a new cytoplasmic MT at the growing tip of an old one (indexed=1)
StartPosition= data.working.dyn.microtubules.Org(1).Verts(end,:);
InitialDirection== data.working.dyn.microtubules.Org(1).CurrentDirection;
[data,newID] = nucleateDyn( data, 'cytoplasm', 'microtubules', ...
StartPosition, InitialDirection );
overlayStats.m
plotCylinderExtrusion.m
plotCylinderExtrusion( ax, h, vxs, radius, npts, colorspec ) Plot a piecewise cylindrical object that passes through the vertexes in VXS, and whose cross-section is a regular polygon of NPTS vertexes and radius RADIUS. The plotting takes place in the axes object AX. If H is nonempty, it is assumed to be a graphics handle returned by a previous call of plotCylinderExtrusion. In this case its properties will be updated instead of a new handle being made. COLORSPEC is a structure with fields START, MIDDLE, END, TIPS, and VARIATION. START, MIDDLE, and END are the colours of the start, middle, and end of the extrusion. VARIATION specifies an amount by which the colour varies around the microtubule. TIPS affects how much the start and end colours are localised to the tips of the cylinder. The larger the value, the more the tip colours are localised. Default values aredefined for each of these properties.
plot_MTStats_Gaussians.m
plot_dynamic_organelle.m
mic, microtubule/actin name, name of dynamic organelle, i.e. microtubule/actin
plot_static_organelles.m
plotfactor.m
plotmarkers.m
p = plotmarkers( points, sizes, color, alpha, shape, ... )
Plot a marker at each of a set of points.
POINTS is an N*3 array of N points.
SIZES is a 1*N or N*1 vector of diameters of the markers.
COLOR is an RGB triple specifying the color of all the markers.
ALPHA is a single number, the alpha value (opacity) of the markers. 1
is completely opaque, 0 is invisibly transparent.
SHAPE is either 'cube', 'octahedron', or 'tetrahedron'.
The remaining arguments are passed on to a call of PATCH. These should
not specify any of 'EdgeColor', 'FaceAlpha', 'EdgeAlpha', or
'LineStyle', but may specify any other properties.
The result is a graphics handle to a patch object.
previousHit.m
h = previousHit( mt, data ) Return the hit structure that records what, if anything the microtubule mt hit on the previous iteration. Note that this procedure can only be called during a simulation step, because the iteration count will be incremented at the end of the step.
pushbutton_initialise.m
initialise the model make an initialising call to the interaction function
pushbutton_restart.m
clear the working arrays
pushbutton_stop.m
quickProximityTest.m
mightBeNear = quickProximityTest( p01, q01, dmin ) Perform a quick proximity test between the point sets defined by the p01 and q01, and the distance dmin. This returns a boolean for each point in q01, which is true if an only if that point is within a distance of d1 of the axis-aligned bounding box of p01. If one wants to know whether the points of q01 are close to any member of p01, or to the convex hull of p01, or to the lines joining the points of p01, then this procedure can be used as a quick screening test. Where it returns false, the point is certainly far, but where it returns true, it may or may not be near, and then a more precise test is needed.
randPosOnMT.m
[p,vi,vr] = randPosOnMT( mt ) Choose N random positions on the microtubule, uniformly by length.
randomSpawnDirection.m
[newdir,newstart,offsetdir] = randomSpawnDirection( ...
curdir, maxangle, maxangleback, curstart, radius, surfnormal, insurface, parallelprob, backprob )
Generate a random direction that deviates by not more than maxangle
from currentdir, and which is uniformly distributed over the spherical
cap that is the space of all permitted directions. If surfnormal is
supplied, nonempty, and nonzero, limit the new vector to the subset making an
angle with surfnormal of more than 90 degrees.
If maxangle is empty, all directions are permitted, the same as if
maxangle were pi or more.
insurface is a boolean. If false, the above happens, but if true, the
new direction is constrained to lie parallel to the surface, i.e.
perpendicular to surfnormal. (surfnormal must be supplied and nonzero
in this case.) The new direction is randomly uniformly distributed
over the range of permitted angles in the surface.
curdir must be a row vector.
newdir will be a unit length row vector.
offsetdir will be a unit vector in the plane of curdir and newdir,
specifying the direction the spawn point should be offset.
The default value of N is 1. A larger value can be supplied to
generate any number of random directions as an N*3 matrix.
randsubset.m
Return a random subset of k of the numbers from 1 to n. s will be an array of booleans the same size as n, with k randonly selected elements set to true. This is guaranteed to give exactly k numbers. If what you need is for each number to be chosen independently with probability k/n, just use s = rand(1,n) < k/n.
rate2prob.m
function p=rate2prob(data,f) convert a transition rate in probability per (second per step) to a probability. (Allard et al use prob per minute) data, MTtbox data structure f, transition probability p, probability
readMTtboxConfig.m
configStruct = readMTtboxConfig() Get config info.
region.m
function [ind,array] = region(data,factor,organellename) data, MTtbox data structure factor, 3D matrix of factor organellename, string e.g. 'cytoplasm' ind, indexes to the region selected by the intersection of the factor and organelle regions array, array the size of the cell containing 1's marking the region usage s_a_p(region(data,id_a_p>0.5,'cytoplasm')=1; % to set s_a_p within the cytoplasm to 1
resetAllMicColours.m
sampleFactor.m
function level=sampleFactor(factor,MT,type)
factor, volume representing the factor, e.g. id_a_p
MT, microtubule data structure
type default 'POSITIVE' or 'GROWING' the growing end
level of factor at the specified point
Usage
if sampleFactor(id_a_p,MT)>0.5
then etc.
saveCurrentState.m
saveMTtboxConfig.m
scaleVertexSize.m
setAlignmentOfAB.m
setAxisTicks.m
setAxisTicks( ax, unit, unitname ) Set the position and labelling of the axis ticks, on the assumption that the unit of labelling is UNIT and not the actual values.
setFactorRole.m
data = setFactorRole( data, role, factorname ) Specify the name of the factor that occupies a given role. If the name is empty or absent, the role is removed.
setMicColour.m
setPlotOptionFromToggleItem.m
setStopRequest.m
Can only be called from within a callback.
setToggleItemFromPlotOption.m
setupDiffusion.m
function data=setupDiffusion(data,varargin)
Diffusion constant may vary from region to region
This routine sets up data structure that can be translated in to a 3D pattern of
diffusion constants.
varargin, data,value pairs where
'Factor' is the name of the signalling factor, e.g. s_factor
'DiffK' is the diffusion constant, N values means that N regions must be specified
'ListOfVolumes', is a list of lists specifying the regions associated with each DiffK
Regionlist i.e. {'plasma_membrane','cytoplasm'} or {'nucleus'}
ListOfVolumes i.e. {{'plasma_membrane','cytoplasm'},{'nucleus'}}
usage
data=setupDiffusion(data,'Factorname','s_a','DiffK',[0.02,0.0],...
'RegionLists',{{'cytoplasm'},{'plasma_membrane','microtubules','vacuole','cell_wall'}});
see also
diffk=setup2DiffusionK(data,'factorname');
J.Andrew Bangham, 2011
setup_static_organelle_volume.m
Fill a volume representing the organelle (used to create a surf for visulisation) save in data.cellprops.(Organelle).Vol Also, use this volume to contribute to the labelling of all regions of the cell save in data.cellprops.Vol This must be done by going through the Organelles from largest to smallest, followed by membranes data.cellprops.Vol be zero everywhere inside the cell and -1 (representing non_cell) outside
showAllMTs.m
show_cortical_microtubules.m
slicefactor.m
smoothStaticOrganelles.m
sortByStageNumber.m
spawnFromMTs.m
data = spawnFromMTs( data ) Spawn new MTs from existing MTs.
splitMT.m
data = splitMT( data, mtID, mtIndex ) Split the microtubule identified either by mtID or mtIndex into two parts at vertex i (an index into its Verts array). That vertex will become the last vertex of the original mt and the first vertex of the new mt.
stopWasRequested.m
Can only be called from within a callback.
surfCollisionDir.m
newDir = surfCollisionDir( previousDir, surfNormal, maxAngle ) A microtubule travelling in direction previousDir collides with a surface, whose surface normal at the collision point is surfNormal, pointing in the direction away from the microtubule. This procedure calculates the resulting direction of the microtubule, which should be tangent to the surface, and subject to that, as close as possible to the original direction. previousDir and surfNormal are assumed to be unit vectors. newDir will be a unit vector. softCollision is true if the angle of incidence with the surface is below maxAngle. The value returned for newDir is independent of whether softCollision is true.
surfDistance.m
[penetrationDistance,penetrationVector] = surfDistance( pt, dir, vertices, normals, normalsense, maxdist, surfsize, planeOnly ) Determine whether the point PT is closer than maxdist to the surface, and if so, how close, and calculate a vector in the direction of the contact, whose length is equal to the penetration depth. This vector always points into the collision object. If PT is not closer than maxdist, then the penetration distance is returned as 0 and the penetration vector as the zero vector.
testDiffuse.m
Set X to be a spherically symmetric gaussian concentration field.
testrandsubset.m
toggleMenuPlotOption.m
trimToVol.m
ijk = trimToVol( ijk, volsize ) Force every component of ijk to lie between 1 and the corresponding component of volsize.
updateFactorListbox.m
updateMTtboxFactorsDialog.m
update_Interaction_Function_Tail.m
function ok=update_Interaction_Function_Tail(data) to ensure that when the interaction function is next opened the commented parameters at the end together with any changes specified in the body of the interaction function represent a complete description of the model
update_control_panel.m
update_nsfregion_menus.m
update_organelle_menus.m
upgradeData.m
validateData.m
ok = validateData( data ) Perform validity checks on the data. These are not exhaustive, but just a collection of whatever tests occurred to me.
viewCombinedFlapHists.m
vieworganelle.m
volSub2ind.m
indexes = volSub2ind( volsize, ipp ) Version of sub2ind that runs much faster than Matlab's.
whichSideOfSurface.m
[side,closestpt,normal,offset] = whichSideOfSurface( pt, surface, normals, maxdist ) Determine whether the point PT is on the positive or negative side of the surface defined by VERTICES and NORMALS. SIDE is 1 if the point is on the side that the normals point towards, otherwise -1. SURFACE is a struct containing two fields, VERTICES and FACES, as returned by ISOSURFACE(). Only the vertices are actually used. Vertexes farther away from PT than MINDIST along any coordinate are ignored. If this leaves no vertices, SIDE will be zero. Otherwise, the closest remaining vertex to PT will be chosen and the normal vector at that point used to determine SIDE. CHOSENPT is the closest vertex to PT. NORMAL is the normal vector at that vertex. OFFSET is the vector such that PT+OFFSET lies in the plane through CHOSENPT perpendicular to NORMAL.
writeDefaultCellParameters.m
writeDefaultFactorParameters.m
writeDefaultOrganelleParameters.m
function writeDefaultOrganelleParameters(data,fid) see GetOrganelleDefaultProps
writeDefaultParameters.m
MicrotubuleModeller.m
function MicrotubuleModeller(varargin) Example: MicrotubuleModeller; Dr. A. I. Hanna (2007) CMP, UEA, 2007.
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\Params
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\Mathematica Versions
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\Mathematica Versions\Library Version
Arg.m
Microtubules.m
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\Mathematica Versions\Library Version\Test
Collatz.m
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\Mathematica Versions\Library-3D
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\Mathematica Versions\OBJUnpickle
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\Mathematica Versions\OldVersions
MTmain.m
A class to handle all the MT admin
Microtubules.m
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMT
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMT\.eric4project
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMT\CellData
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMT\Logs
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMT\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMT\POV-Renders
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMT\Parameters
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMT\Parameters\FlipCell
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMT\Parameters\NoFlipCell
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMT\Parameters\Transmission
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMT\PicklingJar
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMT\build
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMT\build\temp.macosx-10.3-fat-2.6
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMTPanda
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMTPanda\.eric4project
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMultipleMT
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMultipleMT\.eric4project
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PyMultipleMT\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PySingleMT
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PySingleMT\.eric4project
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\PyMicrotubules\PySingleMT\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\MicrotubuleModeller\Tests
rand_orient.m
rand_orient(sensor_type,base_angle,noise)
Exploring ways of plotting changing patterns of orientation
Two state machine producing
orientations at two angles 90 degrees apart
sensor_type, 0 orientations at 0 to 360 degrees
1 modulo 180 (c.f. actual measurements of microtubules
2 modulo 90 for test purposes
base_angle, angle from which 90 excursions occur
noise, 0 to 360 standard deviation of angle measurement error
background, 0 to 1 proportion of instances with background random oriented noise
usage
rand_orient(1,30,3)
J. Andrew Bangham, 2010
rand_orient3.m
rand_orient(sensor_type,base_angle,noise)
Exploring ways of plotting changing patterns of orientation
Two state machine producing
orientations at four angles 0, 50 70 90
sensor_type, 0 orientations at 0 to 360 degrees
1 modulo 180 (c.f. actual measurements of microtubules
2 modulo 90 for test purposes
base_angle, angle from which 90 excursions occur
noise, 0 to 360 standard deviation of angle measurement error
background, 0 to 1 proportion of instances with background random oriented noise
usage
rand_orient(1,30,3)
J. Andrew Bangham, 2010
runnable.m
viewPhases.m
[results,names]=viewPhases(resultsDir,sigma,verbose) resultsDir, directory containing the results text files sigma,minimum distance (along time axis) between min and max verbose, 0 no graphics, 3 full heat map graphic results, data structure names, names of parameters on ordinate (rows) and abscissa (cols) used by viewTuringHeatMap.m J.Andrew Bangham, 2012
viewTuringHeatMap.m
function HM=viewTuringHeatMap(resultsDirectory)
resultsDirectory, string giving the name of a local directory containing all the
MT counts for the two layers
e.g. containing
Phases.VALUESubCorticalMaxLength=8VALUECrossoverExponent=2.txt
Phases.VALUESubCorticalMaxLength=8VALUECrossoverExponent=3.txt
where a typical file two columns of MT counts per time frame, one column per layer
HM, heat map
names, names of parameters being varied - rows cols
it also saves a screenshot of the matrix of plots in the current directory
Usage
viewTuringHeatMap('ForAndrew');
Depends on
viewPhases.m
J. Andrew Bangham, 2012
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectC++
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectJ
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectJ\build
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectJ\build\classes
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectJ\build\classes\omeroconnect
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectJ\dist
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectJ\dist\javadoc
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectJ\dist\javadoc\index-files
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectJ\dist\javadoc\omeroconnect
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectJ\dist\javadoc\omeroconnect\class-use
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectJ\dist\javadoc\resources
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectJ\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectJ\nbproject
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectJ\nbproject\private
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectJ\src
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectJ\src\omeroconnect
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectPy
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectTest
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectTest\build
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectTest\build\classes
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectTest\build\classes\omeroconnecttest
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectTest\dist
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectTest\dist\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectTest\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectTest\nbproject
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectTest\nbproject\private
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectTest\src
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectTest\src\omeroconnecttest
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROConnectTest\test
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROMatlab
Tutorial0.m
TUTORIAL0 How to connect to the omero server and list the whole database
Tutorial1.m
TUTORIAL1 How to connect to the omero server and save a specific ImageID to the local disk
Tutorial2.m
TUTORIAL2 How to connect to the omero server and access an Image object
Tutorial3.m
TUTORIAL3 How to connect to the omero server, access an Image object, process the image and save the results back on the server.
Tutorial4.m
TUTORIAL4 How to connect to the omero server and retrieve Image objects by searching for TAGS.
Tutorial5.m
TUTORIAL5 How to connect to the omero server and perform data management.
Tutorial6.m
TUTORIAL6 How to use annotations.
findAllImages.m
utilityFunctions.m
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROUploader
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROUploader\build
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROUploader\build\classes
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROUploader\build\classes\omeroconnect
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROUploader\build\classes\omerouploader
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROUploader\dist
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROUploader\dist\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROUploader\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROUploader\nbproject
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROUploader\nbproject\private
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROUploader\src
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROUploader\src\omerouploader
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROUploader\test
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMERO_daemon
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMERO_daemon\build
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMERO_daemon\build\classes
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMERO_daemon\build\classes\omero_daemon
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMERO_daemon\dist
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMERO_daemon\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMERO_daemon\nbproject
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMERO_daemon\nbproject\private
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMERO_daemon\src
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMERO_daemon\src\omero_daemon
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMERO_daemon\test
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROtoOMERO
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROtoOMERO\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROtoOMERO\nbproject
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROtoOMERO\nbproject\private
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROtoOMERO\src
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROtoOMERO\src\omerotoomero
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROtoOMERO\test
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OMEROwebsync
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OPT_Uploader
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OPT_Uploader\dist
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OPT_Uploader\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OPT_Uploader\nbproject
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OPT_Uploader\nbproject\private
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OPT_Uploader\src
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\OPT_Uploader\src\opt_uploader
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\dist
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\dist\icons
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\dist\icons\_PAlbTN
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\dist\icons\_PAlbTN\170x128
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\dist\icons\_PAlbTN\320x320
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\dist\icons\_PAlbTN\56x42
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\nbproject
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\nbproject\private
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\src
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\src\qtnetworkclient
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\src\qtnetworkclient\icons
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\src\qtnetworkclient\icons\_PAlbTN
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\src\qtnetworkclient\icons\_PAlbTN\170x128
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\src\qtnetworkclient\icons\_PAlbTN\320x320
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClient\src\qtnetworkclient\icons\_PAlbTN\56x42
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClientC
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClientC\QtNetworkClientC
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClientC\QtNetworkClientC\GeneratedFiles
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClientC\QtNetworkClientC\GeneratedFiles\Debug
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClientC\QtNetworkClientC\GeneratedFiles\Release
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClientC\QtNetworkClientC\_PAlbTN
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClientC\QtNetworkClientC\_PAlbTN\170x128
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClientC\QtNetworkClientC\_PAlbTN\320x320
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClientC\QtNetworkClientC\_PAlbTN\56x42
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtNetworkClients\QtNetworkClientC\release
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtNetworkServer
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtNetworkServer\dist
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtNetworkServer\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtNetworkServer\nbproject
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtNetworkServer\nbproject\private
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtNetworkServer\src
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtNetworkServer\src\qtnetworkserver
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtNetworkServer\src\qtnetworkserver\icons
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtNetworkServer\src\qtnetworkserver\icons\_PAlbTN
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtNetworkServer\src\qtnetworkserver\icons\_PAlbTN\170x128
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtNetworkServer\src\qtnetworkserver\icons\_PAlbTN\320x320
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtNetworkServer\src\qtnetworkserver\icons\_PAlbTN\56x42
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\dist
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\dist\icons
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\dist\icons\_PAlbTN
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\dist\icons\_PAlbTN\170x128
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\dist\icons\_PAlbTN\320x320
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\dist\icons\_PAlbTN\56x42
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\jui
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\nbproject
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\nbproject\private
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\oldcode
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\src
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\src\qtomeclient
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\src\qtomeclient\icons
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\src\qtomeclient\icons\_PAlbTN
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\src\qtomeclient\icons\_PAlbTN\170x128
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\src\qtomeclient\icons\_PAlbTN\320x320
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\QtOmeClient\src\qtomeclient\icons\_PAlbTN\56x42
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeImageIO
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeImageIO\dist
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeImageIO\dist\javadoc
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeImageIO\dist\javadoc\index-files
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeImageIO\dist\javadoc\omeImageIO
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeImageIO\dist\javadoc\omeImageIO\class-use
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeImageIO\dist\javadoc\resources
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeImageIO\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeImageIO\nbproject
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeImageIO\nbproject\private
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeImageIO\src
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeImageIO\src\omeImageIO
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeServerBrowser
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeServerBrowser\dist
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeServerBrowser\dist\javadoc
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeServerBrowser\dist\javadoc\index-files
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeServerBrowser\dist\javadoc\omeServerBrowser
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeServerBrowser\dist\javadoc\omeServerBrowser\class-use
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeServerBrowser\dist\javadoc\resources
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeServerBrowser\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeServerBrowser\nbproject
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeServerBrowser\nbproject\private
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeServerBrowser\src
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\QtOMEBrowser\omeServerBrowser\src\omeServerBrowser
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\ScreenShot
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\ScreenShot\build
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\ScreenShot\build\classes
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\ScreenShot\build\classes\screenshot
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\ScreenShot\dist
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\ScreenShot\dist\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\ScreenShot\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\ScreenShot\nbproject
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\ScreenShot\nbproject\private
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\ScreenShot\src
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\ScreenShot\src\screenshot
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\ScreenShot\src\screenshot\web
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\ScreenShot\test
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\bioformatsConverter
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\bioformatsConverter\dist
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\bioformatsConverter\lib
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\bioformatsConverter\nbproject
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\bioformatsConverter\nbproject\private
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\bioformatsConverter\src
C:\Users\AB\DArT_Toolshed\Toolboxes\OpenMicroscopyToolbox\bioformatsConverter\src\bioformatsconverter
C:\Users\AB\DArT_Toolshed\Toolboxes\OpticalFlowTool
OpticalFlowTool.m
function OpticalFlowTool(varargin) A tool that allows the user to load and crop avi files and then compute the direction of flow using an optical flow algorithm. Example: OpticalFlowTool; Dr. A. I. Hanna, CMP, UEA, 2008.
C:\Users\AB\DArT_Toolshed\Toolboxes\OpticalFlowToolPlus
CalcCyclicMeanTheta.m
function returns meanTheta, the mean angle from an array of angles Requires upLim and lowLim which are the upper and lower limits of the search.
OpticalFlowToolPlus.m
function OpticalFlowToolPlus(varargin) A tool that allows the user to load and crop avi files and then compute the direction of flow using an optical flow algorithm. Example: OpticalFlowToolPlus;
calcOrderCoefficient.m
circMean.m
data is a frequency count of 180 elements (each bin is 1 degree)
csvimport.m
CSVIMPORT reads the specified CSV file and stores the contents in a cell array or matrix
The file can contain any combination of text & numeric values. Output data format will vary
depending on the exact composition of the file data.
CSVIMPORT( fileName ): fileName - String specifying the CSV file to be read. Set to
[] to interactively select the file.
CSVIMPORT( fileName, ... ) : Specify a list of options to be applied when importing the CSV file.
The possible options are:
delimiter - String to be used as column delimiter. Default
value is , (comma)
columns - String or cell array of string listing the columns
from which data is to be extracted. If omitted data
from all columns in the file is imported.
outputAsChar - true / false value indicating whether the data
should be output as characters. If set to false the
function attempts to convert each column into a
numeric array, it outputs the column as characters
if conversion of any data element in the column
fails. Default value is false.
uniformOutput - true / false value indicating whether output can be
returned without encapsulation in a cell array.
This parameter is ignored if the columns / table
cannot be converted into a matrix.
noHeader - true / false value indicating whether the CSV
file's first line contains column headings. Default
value is false.
ignoreWSpace - true / false value indicating whether to ignore
leading and trailing whitespace in the column
headers; ignored if noHeader is set to true.
Default value is false.
The parameters must be specified in the form of param-value pairs, parameter names are not
case-sensitive and partial matching is supported.
[C1 C2 C3] = CSVIMPORT( fileName, 'columns', {'C1', 'C2', C3'}, ... )
This form returns the data from columns in output variables C1, C2 and C3 respectively, the
column names are case-sensitive and must match a column name in the file exactly. When fetching
data in column mode the number of output columns must match the number of columns to read or it
must be one. In the latter case the data from the columns is returned as a single cell matrix.
[C1 C2 C3] = CSVIMPORT( fileName, 'columns', [2, 3, 4], ,'noHeader', true, ... )
This form returns the data from columns in output variables C1, C2 and C3 respectively, the
columns parameter must contain the column indices when the 'noHeader' option is set to true.
ellipse_fit2d.m
function [data] = ellipse_fit2d(PC)
This function fits an ellipse to some data given by PC.
Input Params:
PC - this is an Mx2 matrix of x, y coordinates that specify a region
Output Params:
data - this is a structure that contains the information about the ellipse
as follows:
data.Orientation - the principle direction of the ellipse
data.MajorAxisLength - length along the principle direction
data.MinorAxisLength - length along the minor axis
data.Centroid - this is an 1x2 vector of x and y coordinates
data.Area - this is the length of the data 'PC', i.e. the number of
pixels for that sector.
Dr. A. I. Hanna (2006).
microOrientate.m
normHistForLength.m
normalise histogram for line lengths at different angles (45 degrees line should count for mor than a vert or hori line).
normalise.m
NORMALISE - Normalises image values to 0-1, or to desired mean and variance
Usage:
n = normalise(im)
Offsets and rescales image so that the minimum value is 0
and the maximum value is 1. Result is returned in n. If the image is
colour the image is converted to HSV and the value/intensity component
is normalised to 0-1 before being converted back to RGB.
n = normalise(im, reqmean, reqvar)
Arguments: im - A grey-level input image.
reqmean - The required mean value of the image.
reqvar - The required variance of the image.
Offsets and rescales image so that it has mean reqmean and variance
reqvar. Colour images cannot be normalised in this manner.
plotridgeorient.m
PLOTRIDGEORIENT - plot of ridge orientation data
Usage: plotridgeorient(orient, spacing, im, figno)
orientim - Ridge orientation image (obtained from RIDGEORIENT)
spacing - Sub-sampling interval to be used in ploting the
orientation data the (Plotting every point is
typically not feasible)
im - Optional fingerprint image in which to overlay the
orientation plot.
figno - Optional figure number for plot
A spacing of about 20 is recommended for a 500dpi fingerprint image
See also: RIDGEORIENT, RIDGEFREQ, FREQEST, RIDGESEGMENT
rad2deg.m
rayleigh.m
critical z val for alpha=0.05, for n = inf is 2.9957. if z > 2.9957 reject H0.
ridgeOrientationPaul.m
squaring the gradient vectors: Kass and Witkin "Analysing oriented patterns" Computer Vision, Graphics and Image Processing, vol. 37, pp. 362-385, 1987. sigmas need to be odd
ridgeorientation.m
Arguments: im - A normalised input image.
gradientsigma - Sigma of the derivative of Gaussian
used to compute image gradients.
blocksigma - Sigma of the Gaussian weighting used to
sum the gradient moments.
orientsmoothsigma - Sigma of the Gaussian used to smooth
the final orientation vector field.
Returns: orientim - The orientation image in radians.
Orientation values are +ve clockwise
and give the direction *along* the
ridges.
ridgesegment.m
RIDGESEGMENT - Normalises fingerprint image and segments ridge region
Function identifies ridge regions of a fingerprint image and returns a
mask identifying this region. It also normalises the intesity values of
the image so that the ridge regions have zero mean, unit standard
deviation.
This function breaks the image up into blocks of size blksze x blksze and
evaluates the standard deviation in each region. If the standard
deviation is above the threshold it is deemed part of the fingerprint.
Note that the image is normalised to have zero mean, unit standard
deviation prior to performing this process so that the threshold you
specify is relative to a unit standard deviation.
Usage: [normim, mask, maskind] = ridgesegment(im, blksze, thresh)
Arguments: im - Fingerprint image to be segmented.
blksze - Block size over which the the standard
deviation is determined (try a value of 16).
thresh - Threshold of standard deviation to decide if a
block is a ridge region (Try a value 0.1 - 0.2)
Returns: normim - Image where the ridge regions are renormalised to
have zero mean, unit standard deviation.
mask - Mask indicating ridge-like regions of the image,
0 for non ridge regions, 1 for ridge regions.
maskind - Vector of indices of locations within the mask.
Suggested values for a 500dpi fingerprint image:
[normim, mask, maskind] = ridgesegment(im, 16, 0.1)
See also: RIDGEORIENT, RIDGEFREQ, RIDGEFILTER
trklib_csv2track.m
CSV2TRACK(filename) Extract the data from a csv file create with the point_tracking python tool and convert it for the TrackingToolbox
vTest.m
v-test to test whether the observed angles have a tendency to cluster around a given angle. data is a vector of angles in degrees, modified for axial data. for alpha = 0.05 n=1000 vScore crit val is 1.6449
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\CellData
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Logs
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\FlipCell
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\LayerFlipCell17
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\LayerFlipCell37
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\LayerFlipping
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\LayerFlippingSides
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\NoFlipCell
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\NoFlipCellReal17
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\NoFlipCellReal17For3D
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\NoFlipCellReal37
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\NoFlipCellReal37For3D
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\NoFlipCellReal4
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\NoFlipCellReal6a
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\Transmission
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\TransmissionCellReal17For3D
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\TransmissionCellReal37For3D
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\TransmissionFlipCell17
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\TransmissionFlipCell37
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\OldParameters\TransmissionReal
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\POV-Renders
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\DoubleCrosslinks
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\DoubleCrosslinks\CellData
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\DoubleCrosslinks\Logs
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\DoubleCrosslinks\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\DoubleCrosslinksReal
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\DoubleCrosslinksReal\CellData
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\DoubleCrosslinksReal\Logs
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\DoubleCrosslinksReal\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\DoubleCrosslinksRectangle
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\DoubleCrosslinksRectangle\CellData
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\DoubleCrosslinksRectangle\Logs
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\DoubleCrosslinksRectangle\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\LengthDependentCat
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\LengthDependentCat\CellData
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\LengthDependentCat\Logs
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\LengthDependentCat\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\OnePlaneCollisions
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\OnePlaneCollisions\CellData
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\OnePlaneCollisions\Logs
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\OnePlaneCollisions\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringCopyTest
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringCopyTest\CellData
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringCopyTest\Logs
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringCopyTest\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringCrosslinks
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringCrosslinks\CellData
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringCrosslinks\Logs
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringCrosslinks\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringDiffusion
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringDiffusion\CellData
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringDiffusion\Logs
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringDiffusion\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringHysteresis
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrossNoNuc
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrossNoNuc\CellData
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrossNoNuc\Logs
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrossNoNuc\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrosslinks
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrosslinks\CellData
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrosslinks\Logs
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrosslinks\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrosslinksReal
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrosslinksReal\CellData
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrosslinksReal\Logs
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrosslinksReal\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrosslinksRectangle
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrosslinksRectangle\CellData
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrosslinksRectangle\Logs
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\Parameters\TuringLocalCrosslinksRectangle\Movies
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\PicklingJar
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\build
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\build\temp.macosx-10.3-fat-2.6
C:\Users\AB\DArT_Toolshed\Toolboxes\PyMicrotubules\pymt\build\temp.macosx-10.5-i386-2.6
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\DisplayFunctions
satdisp_list.m
function satdisp_list A function that lists the display functions for SAToolbox Dr. A. I. Hanna (2007)
satdisp_sector_coverage.m
function varargout = satdisp_sector_coverage(varargin)
Display method for showing the proportion of the petal covered by sectors
in the SA toolbox
Usages:
satdisp_sector_coverage('parent', gca);
Dr. A. I. Hanna (2007)
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\IOFunctions
satio_export_av_grid_data_to_excel.m
function satio_export_av_grid_data_to_excel A function that exports the average sector data for a grid to a file. See also: satio_list Dr. A. I. Hanna (2007)
satio_export_growth_data_to_excel.m
function satio_export_growth_data_to_excel A function that exports the growth data from an ungrowth file to excel See also: satio_list Dr. A. I. Hanna (2007)
satio_list.m
function satio_list A function that lists all the I/O functions for SectorAnalysisToolbox Dr. A. I. Hanna (2007)
satio_load_mean_shape.m
function satio_load_mean_shape A method that loads the mean shape for the current project, if the mean shape does not exist, the function returns an empty matrix. See also: satio_list Dr. A. I. Hanna (2007)
satio_load_ungrowth.m
function varargout = satio_load_ungrowth(varargin)
IO Method for loading ungrowth data in the SA toolbox
Usages:
ungrowth_data = satlib_load_ungrowth('filename', filename);
or
ungrowth_data = satlib_load_ungrowth;
See also: satio_list
Dr. A. I. Hanna (2007)
satio_load_warped_sector_info.m
function varargout = satio_load_warped_sector_info(varargin)
IO Method for loading warped sector data in the SA toolbox
Usages:
warped_sector_info = satio_load_warped_sector_info('organ_directory', direc);
or
warped_sector_info = satio_load_warped_sector_info;
See also: satio_list
Dr. A. I. Hanna (2007)
satio_meshes2GrowthData.m
satio_opengrid.m
function varargout = satio_opengrid(varargin)
i/o function for loading grids in the SA toolbox
Usage:
grid = satlib_opengrid('filename', filename);
or
grid = satlib_opengrid;
See also: satio_list
Dr. A. I. Hanna (2007)
satlib_individualsectorStats2Excel.m
satlib_sectorStats2Excel.m
function satlib_sectorStats2Excel(varargin) Dr. A. I. Hanna, CMP, 2008.
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\LibraryFunctions
get_warped_stage_data.m
function [x, n] = get_warped_stage_data(stage_dir, number_of_pixels_per_cell) A function that takes a stage directory and a scalar that defines the number of pixels per cell. Returns the center of the bins and the frequency of a particular sector size for that stage. This can then be used in a histogram plot to stage images. Dr. A. I. Hanna (2006)
interpolateGrowthField.m
plot_grid_old.m
plot_mean_shape.m
rtable.m
satlib_drawGridData.m
function satlib_drawGridData(varargin) This method takes a grid and draws the growth information on the grid. Inputs: grid (default = []) colours (default = 'g') axish (default = []) edgecolor (default = 'k') tensorcol (default = 'k') Dr. A. I. Hanna, CMP & JIC, Norwich, UK, 2008
satlib_drawRegions.m
function figvec = satlib_drawRegions(varargin) Dr. A. I. Hanna, CMP, 2008.
satlib_plot_region_patches.m
satlib_plot_ungrowth_data.m
function satlib_plot_ungrowth_data(varargin)
Shows the areal growth real and anisotropy for ungrowth data
example 1
show_region_areal_growth;
example 2
show_region_areal_growth('ungrowthfilename', 'Staged\Data\UngrowthData\Ungrowth_aih_001.mat', 'scale', 0);
Dr. A. I. Hanna (2007)
satlib_warpRegularMesh.m
function figvec = satlib_warpRegularMesh(varargin) Generates and warps a regular grid according to the deformation of the supplied ungrown grids. Uses the motion coherence library to determine the warp. It has been proven that for sparse data sets the chosen regularizer in mctlib satisfies the two constraints for regularizers put forward by Yuille. Dr. A. I. Hanna, CMP, 2008
show_all_stages.m
show_average_ellipses_all_stages.m
show_average_ellipses_all_stages(mean_shape_dir, stage_dir) Dr. A. I. Hanna (2005);
show_average_ellipses_for_stage.m
show_average_ellipses_for_stage(mean_shape_dir, stage_dir) Dr. A. I. Hanna (2005);
show_average_stage_growth_rate.m
show_average_stage_growth_rate(mean_shape_dir, grid_name) Dr. A. I. Hanna (2005);
show_mean_sector_area.m
[ma] = show_mean_sector_area() Dr. A. I. Hanna (2005);
show_region_areal_growth.m
function show_region_areal_growth(varargin)
Shows the areal growth real and anisotropy for ungrowth data
example 1
show_region_areal_growth;
example 2
show_region_areal_growth('ungrowthfilename', 'Staged\Data\UngrowthData\Ungrowth_aih_001.mat', 'scale', 0);
Dr. A. I. Hanna (2007)
show_sectors_for_stage.m
stage_dir = 'Staged\P38\'; mean_shape_dir = 'Staged\Data';
show_stage_sector_info.m
show_stage_sector_info(mean_shape_dir, stage_dir) Dr. A. I. Hanna (2005);
show_variance_in_orientation.m
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\SectorAnalysisToolbox
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\SectorAnalysisToolbox\EdgeEditor
EdgeEditor.m
Hanna, 2005
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\SectorAnalysisToolbox\GridEditorTool
Copy of GridEditorTool.m
function [value] = GridEditorTool(varargin) Notes: every region must have at least 4 control points so we can find an inverse transform for the strain matrix. Hanna, 2005
GridEditorTool.m
function GridEditorTool(varargin) Notes: every region must have at least 4 control points so we can find an inverse transform for the strain matrix. Hanna, 2007
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\SectorAnalysisToolbox\GridFunctions
auto_regions.m
function auto_regions(reg_x, reg_y, Xm) A function that takes the number of regions in the x-direction
build_regions.m
function grid = build_regions(grid) A function that takes a grid and uses the region vertices and the control points to build the regions. Dr. A. I. Hanna (2007)
calcDeficientRegions.m
function [density, empty_regions] = calcDeficientRegions(T, pts, regions_ind, xydata) Dr. A. I. Hanna (2007)
calcRegionalGrowthTensors.m
for each region that is not empty, merge surrounding regions if they are empty.
calcStageGridCentroids.m
drawGrid_old.m
drawStageGrowthTensors.m
findRegionContainingTri.m
function id = findRegionContainingTri(regind, triid) Dr. A. I. Hanna (2007)
findTouchingTriangles.m
function tind = findTouchingTriangles(T, tri_in_region) Dr. A. I. Hanna (2007)
getCentroid.m
function centroid = getCentroid(r) Returns the centroid of a binary image. Dr. A. I. Hanna (2007)
getGridId.m
function curr_stage_ind = getGridId(organ_grid, stage) Dr. A. I. Hanna (2007)
getRegionCornerPts.m
grid2triangulation.m
function [T, tri_pts] = grid2triangulation(mature_grid) Dr. A. I. Hanna (2007)
init_grid.m
function grid = init_grid(grid) This function initializes the grid Dr. A. I. Hanna (2007)
interp_region_pts.m
makeExternalSprings.m
makeInternalSprings.m
makeRegionSprings.m
makeShapeSprings.m
makeSpringsFromTri.m
function [grid] = makeSpringsFromTri(grid) Dr. A. I. Hanna (2007)
merge_regions.m
function grid = merge_regions(grid, region_ind) A function that takes a grid and indices to the regions to merge. The function returns the new grid with the regions updates and automatically builds the springs. Dr. A. I. Hanna (2007)
optimizeGridForStagePair.m
order_xy_pts.m
function [rpts] = order_xy_pts(pts) Dr. A. I. Hanna (2006).
plot_adj_graph.m
plot_all_grid_stages.m
plot_centroids.m
plot_grid.m
function ph = plot_grid(grid, axish, i)
plot_region_density.m
plot_region_patches.m
plot_shape.m
plot_springs.m
plot_stage_grid.m
pts2binim.m
function [R] = pts2binim(pts) Given some Nx2 matrix of ordered points defining a shape this function call will return a PxQ binary image of the shape. Example theta = 0:.1:2*pi; x = 20*cos(theta) + 30; y = 10*sin(theta) + 30; R = pts2binim([x', y']); imagesc(R); Dr. A. I. Hanna (2005)
segmentOrgan.m
stage_info2average_region_info.m
triFindNeighbours.m
function regind = triFindNeighbours(T, tri_in_region) Dr. A. I. Hanna (2007)
validateGridForStage.m
Extract the triangulation information
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\SectorAnalysisToolbox\ImageProcessingTool
ImageProcessingTool.m
Hanna, 2005
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\SectorAnalysisToolbox\OptimiseGridTool
OptimiseGridTool.m
Hanna, 2005
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\SectorAnalysisToolbox\SATPlotOptionsTool
SATPlotOptionsTool.m
function SATPlotOptionsTool A small utility that allows the user to select some plot options before displaying the ungrowth data. Usage: >>SATPlotOptionsTool Dr. A. I. Hanna, CMP & JIC, Norwich, UK, 2008.
SATWarpParamsDlg.m
function SATWarpParamsDlg A small utility that allows the user to select some plot options before displaying the ungrowth data. Usage: >>SATWarpParamsDlg Dr. A. I. Hanna, CMP & JIC, Norwich, UK, 2008.
tri2boundary.m
triplotedges.m
SectorAnalysisToolbox.m
function SectorAnalysisToolbox Example: SectorAnalysisToolbox; Dr. A. I. Hanna (2007) CMP, UEA, 2008.
SectorAnalysisToolboxOLD.m
Hanna, 2005 Global figure handles
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\SectorAnalysisToolbox\SectorAreaTool
SectorTool.m
function SectorAreaTool(varargin) Notes: every region must have at least 4 control points so we can find an inverse transform for the strain matrix. Hanna, 2007
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\SectorAnalysisToolbox\SectorEditorTool
SectorEditorTool.m
function [value] = SectorEditorTool(varargin) This is the sector editor tool, it allows the user to erode, dilate, merge, delete add sectors. You can also edit the point model for the organ and you can recalculate any of the sectors and organs at any time. Dr. A. I. Hanna (2007)
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\SectorAnalysisToolbox\SectorWarpingTool
SectorWarpingTool.m
Hanna, 2005
warpSectorsViaTriangles.m
warpSectorsViaTrianglesConcave.m
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\SectorAnalysisToolbox\SegmentationAlgorithms
Erika_CellDivisionPlanes.m
GFP_confocal.m
do some image normalise - (don't really need to do this tho)
GFP_confocal_MSE.m
do some image normalise - (don't really need to do this tho)
JRK_sectors.m
amelia_petal_sectors.m
#function checknargin
clear all;
w = waitbar(0, 'Testing...');
im = imread('C:\Documents and Settings\aih\My Documents\post_doc\amelia\Images\StagedTestSet\S4\P10F15P1I.JPG');
im = imread('C:\Documents and Settings\aih\My Documents\post_doc\amelia\Images\StagedTestSet\S4\P7F22P1I.JPG');
im = imread('C:\Documents and Settings\aih\My Documents\post_doc\amelia\Images\StagedTestSet\S1\P12F8P1I.JPG');
im = imread('C:\Documents and Settings\aih\My Documents\post_doc\amelia\Images\StagedTestSet\S4\P12F18P1I.JPG');
im = imread('C:\Documents and Settings\aih\My Documents\post_doc\amelia\Images\StagedTestSet\S4\P10F17P1I.JPG');
im = imread('C:\Documents and Settings\aih\My Documents\post_doc\amelia\Images\StagedTestSet\S3\P12F12P1I.JPG');
im = imread('C:\Documents and Settings\aih\My Documents\post_doc\amelia\Images\P7\P21F11-2P1I_small_cluster.JPG');
im = imread('C:\Documents and Settings\aih\My Documents\post_doc\amelia\Images\P7\F33F3082_cells.JPG');
im = imresize(im, .5);
sandra_leaf_sectors.m
sandra_leaf_sectors2.m
function [w, orig, im, bim, S2] = sandra_leaf_sectors2(I, w) A function that takes an image and a handle to a waitbar and returns the waitbar handle, the original image, the image with the sectors overlayed, the binary image of the organ, and the binary image of the sectors. This script has been written for Sandra Bensmihen (JIC) for use with the expression of a cell autonomous marker (anthocyanin) in Antirrhinum majus leaves. Dr. A. I. Hanna (2006)
segment_antirrhinum_anthocyanin_leaves.m
function [w, orig, im, bim, S2] = antirrhinum_anthocyanin_leaves(I, w)
segment_test_data.m
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\SectorAnalysisToolbox\SpringFunctions
makeShapeSprings.m
satlib_calcPenalty.m
function [Fpenalty, Dnew] = satlib_calcPenalty(varargin)
Calculates the penalties for a set of points in a triangulated mesh given
an original distance for each point to its opposite edge. THis is
intended to stop triangles overlapping.
Inputs:
Dorig - the cell array of original distances from each point to its
opposite edges
xyedg - the matrix of points in the mesh
T - the Mx3 matrix defining the triangulation of the mesh.
Outputs:
Fpenalty - the matrix containing the penalties for each point
Dnew - the cell array of updated distances from each point to its
opposite edges
Dr. A. I. Hanna, CMP, 2008.
satlib_relaxSprings.m
function [S, iter2,plotrE] = satlib_relaxSprings(varargin) Dr. A. I. Hanna, CMP, 2008.
satlib_shrinkMesh.m
function base_grid = satlib_shrinkMesh(stage_ungrowth_tensors, base_grid) Shrinks the entire mesh to its new estimated size before relaxing the springs. This removes some error from the spring relaxation. Dr. A. I. Hanna, CMP, 2008.
satlib_triDist2OppEdge.m
function [D, normVec] = satlib_triDist2OppEdge(varargin)
Calculates the distance and normal vector to the opposite edge of a
triangle for each point in the mesh defined by T.
Inputs:
xy - the NxD matrix of points in the mesh, each point is of dimension D
T - the Mx3 matrix defining the triangulation of the mesh.
Outputs:
D - the cell array of distances
normVec - the cell of unit normal vectors from the point P to the
opposite edge.
Dr. A. I. Hanna, CMP, 2008.
satlib_ungrow.m
function [ungrown_grids] = satlib_ungrow(varargin) Dr. A. I. Hanna (2007)
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\SectorAnalysisToolbox\StatViewerTool
SaveSectorAreaToExcel.m
function to output the distances from each sector from the tip or the base to excel together with the size of the sector.
StatViewerTool.m
Hanna, 2005
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\SectorAnalysisToolbox\UngrowingTool
UngrowingTool.m
Hanna, 2005
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\AlignShape
AlignShape.m
Hanna, 2005
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\BoltzmannFitting
boltzmann.m
function y = boltzmann(bottom, top, tm, slope, x)
boltzmann_nonlinear_stage.m
function x = boltzmann_nonlinear_fit(bottom, top, tm, slope, S) Dr. A. I. Hanna (2007)
boltzmann_smoothing.m
boltzmann_stage_error_func.m
function e = boltzmannerrorfunc(x, bottom, top, tm, slope, s) This function calculates the error between the estimated output from the Boltzmann function and the input sizes. Dr. A. I. Hanna (2007)
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\CompareCloneTool
CompareCloneTool.m
function CompareCloneTool(varargin)
A tool that takes a list of binary images and a corresponding list of rgb
images and then lets the user click on sectors in any image. As the user
clicks on a sector, the best fitted ellipse for that sector will be
shown. If the user then clicks on another sector, the corresponding
ellipse for that sector is displayed and the growth tensor that
corresponds to the two ellipses is then calculated and shown in another
figure.
Inputs:
'bimgfilenames' - a cell array containing the full pathnames of the
binary images (usually tif no compression).
'imgfilenames' - a cell array containing the full pathnames of the
rgb images.
Dr. Andrew I. Hanna, CMP & JIC, 2008.
SATLib_RunCompareCloneTool.m
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\CompareWarpedCloneTool
CompareWarpedCloneTool.m
function CompareWarpedCloneTool(varargin)
A tool that takes a list of binary images and a corresponding list of rgb
images and then lets the user click on sectors in any image. As the user
clicks on a sector, the best fitted ellipse for that sector will be
shown. If the user then clicks on another sector, the corresponding
ellipse for that sector is displayed and the growth tensor that
corresponds to the two ellipses is then calculated and shown in another
figure.
Inputs:
'bimgfilenames' - a cell array containing the full pathnames of the
binary images (usually tif no compression).
'imgfilenames' - a cell array containing the full pathnames of the
rgb images.
Dr. Andrew I. Hanna, CMP & JIC, 2008.
SATLib_RunCompareWarpedCloneTool.m
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\ConcavityCheck
ConcavityCheck.m
Hanna, 2005
Edgs2xy_regions.m
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\EditEdgePoints
EditEdgePoints.m
Hanna, 2005
ExportSectorNumbersToExcel.m
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\FindFilenames
findfiles.m
Finds all files with the specified extension in the current directory and
subdirectories (recursive). Returns a cell array with the fully specified
file names.
files = findfiles( ext )
searches in the current directory and subdirectories.
files = findfiles( ext, directory)
starts search in directory specified.
files = findfiles( ext, directory, searchSubdirectories )
If searchSubdirectories == 0, the function will not descend
subdirectories. The default is that searchSubdirectories ~= 0.
Note: if this function causes your recursion limit to be exceeded, then
it is most probably trying to follow a symbolic link to a directory that
has a symbolic link back to the directory it came from.
Examples:
bmpfiles = findfiles('bmp')
dllfiles = findfiles('dll','C:\WinNT')
mfiles = findfiles('m',matlabroot)
findfilesext.m
Finds all files with the specified extension in the current directory and
subdirectories (recursive). Returns a cell array with the fully specified
file names.
files = findfiles( ext )
searches in the current directory and subdirectories.
files = findfiles( ext, directory)
starts search in directory specified.
files = findfiles( ext, directory, searchSubdirectories )
If searchSubdirectories == 0, the function will not descend
subdirectories. The default is that searchSubdirectories ~= 0.
Note: if this function causes your recursion limit to be exceeded, then
it is most probably trying to follow a symbolic link to a directory that
has a symbolic link back to the directory it came from.
Examples:
bmpfiles = findfiles('bmp')
dllfiles = findfiles('dll','C:\WinNT')
mfiles = findfiles('m',matlabroot)
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\GrowthTensor
Export2FEMGrowthTool.m
check_principal_directions.m
function [ungrowth_tensors] = check_principal_directions(ungrowth_tensors) Takes a cell array where each element corresponds to a stage of ungrowth and contains a 3x3xN matrix where N is the number of regions on the organ. For each of the growth tensors, the principal direction of growth is
growthParamsFromTensor.m
Given an N*6 matrix of N growth tensors as row 6-vectors, compute N*1 arrays of the major growth, minor growth, and angle. The growth tensors are assumed to be given in the plane of the cell, i.e. one principal axis is the local z axis.
growthTensorFromParams.m
growth_tensors_to_scaling_factors.m
function [scaling_factors] = growth_tensors_to_scaling_factors(growth_params) Dr. A. I. Hanna (2007)
smooth_growth_parameters.m
function [smooth_growth_parameters] = smooth_growth_parameters(growth_parameters, neighbours) Take the average of the current regions growth tensor with those of its neighbours Dr. A. I. Hanna (2007)
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\MeshGeneration
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\NoiseRemovalTool
NoiseRemovalTool.m
Hanna, 2005
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\OBJTools
Export2ObjFormat.m
growthstruct2obj.m
function growthstruct2obj(growthparamsfilename)
Dr. A. I. Hanna
growthparams = load('matlabgrowthdata2.mat');
SAToolboxLibraryCheck.m
function str = SAToolboxLibraryCheck Dr. A. I. Hanna (2007)
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\SectorCompareTool
SATLib_RunSectorCompareTool.m
SectorCompareTool.m
function SectorCompareTool(varargin)
A tool that takes a list of binary images and a corresponding list of rgb
images and then lets the user click on sectors in any image. As the user
clicks on a sector, the best fitted ellipse for that sector will be
shown. If the user then clicks on another sector, the corresponding
ellipse for that sector is displayed and the growth tensor that
corresponds to the two ellipses is then calculated and shown in another
figure.
Inputs:
'bimgfilenames' - a cell array containing the full pathnames of the
binary images (usually tif no compression).
'imgfilenames' - a cell array containing the full pathnames of the
rgb images.
Dr. Andrew I. Hanna, CMP & JIC, 2008.
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\SegmentationMethods
ErikaCellPlanes.m
not necessary, just to make a new handle and because I'm rubbish at programming;
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\SelectFilesUI
SelectFilesUI.m
[selection,value] = SelectFilesUI(varargin) This little tool allows you to select multiple directories (except those with '.' at the front. Dr. A. I. Hanna
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\SelectGridPointsUtil
SelectGridPointsUtil.m
Hanna, 2005
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\ShowGrowthTool
ShowGrowthTool.m
function ShowGrowthTool A tool that shows the result from the ungrowth tool, a widget in the sector analysis toolbox. See also: SectorAnalysisToolbox, UngrowingTool Dr. A. I. Hanna (2007)
ShowWarpedEllipses.m
function ShowWarpedEllipses A utility to be used with the SectorAnalysisToolbox. This tool allows the user to select a stage (or several) of development. It then loads and displays the warped ellipses for each sector for each sample in the stage onto the mean shape. Dr. A. I. Hanna, CMP & JIC, 2008. Modified by Erika, 2009.
ShowWarpedSectors.m
function ShowWarpedSectors A utility to be used with the SectorAnalysisToolbox. This tool allows the user to select a stage of development. It then loads and displays the warped sectors for each sample in the stage onto the mean shape. Dr. A. I. Hanna, CMP & JIC, 2008.
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\ToolsToImportAnne-Gaelle_Data
1_seperate_left_and_right.m
create_structure.m
make_sectors_xy.m
rewrite_tif.m
rewrite_tiff.m
seperate_left_and_right_1.m
transform_tif.m
TranMat2CrossStrain.m
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\UngrowMethods
ungrow_aih.m
function [R, ungrowth_params] = ungrow_aih(R, ungrowth_params, extern_iter, spr_const, recalc_flag, animate, axis_handle, error_axis_handle) Dr. A. I. Hanna (2007)
ungrow_assumption_one.m
function [UngrowthData] = ungrow_assumption_one(R, growth_params, intern_iter, intern_spr_const, extern_iter, extern_spr_const, NM, animate, axis_handle, error_axis_handle) Dr. A. I. Hanna (2006)
ungrow_assumption_three.m
function [R, growth_params] = ungrow_assumption_three(R, growth_params, extern_iter, spr_const, recalc_flag, animate, axis_handle, error_axis_handle) Dr. A. I. Hanna (2007)
ungrow_assumption_two.m
function [UngrowthData, growth_params] = ungrow_assumption_two(R, growth_params, extern_iter, extern_spr_const, recalc_flag, animate, axis_handle, error_axis_handle) Dr. A. I. Hanna (2007)
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\UngrowToolMethods
calculate_growth_params.m
av_info, is a cell structure, where av_info{1} corresponds to smaller
sectors, and so corresponds to later development, this should be used
first when ungrowing. I.e. we use the growth factors that were calculated
at the end of development to start the ungrow. In this way we will use
the data from the larger sectors when then organ is nearly fully ungrown.
calculate_growth_params_from_gt.m
calculate_scaling_factors.m
%%%%%%%%%%%%%%%%%%%%%%%%%% calculate_scaling_factors %%%%%%%%%%%%%%%%%%%%%%%%%%%
get_stage_grid_info.m
function [av_info, sectorsizeinfo] = get_stage_grid_info(stages, organ_grid) Dr. A. I. Hanna (2007)
growthTensor2growthFactor.m
function [gf] = growthTensor2growthFactor(gt, t) Takes a cell array of growth data and a doubling time t, and returns a growth rate and an anisotropy. Dr. A. I. Hanna (2007)
adjust_corners.m
align_edge_vertices2edge.m
autoMakeGrid.m
autoRemoveSmallRegions.m
auto_region_from_gridim.m
av_angle.m
Z=av_angle(A)
Find an approximation to average angle, problem with being circular.
A : vector of angles in radians -pi/2<=theta<=pi/2
Method: Returns Z where it minimises
sum((rem(A+Z,180)-90).^2) {0<=Z<180}
(c) Stephen Impey, 1996-8
average_ellipse_av_growth_tensor.m
average_ellipse_vec_add.m
average_sector_data2xls.m
binim2SortedEdge.m
E = binim2SortedEdge(binim) Dr. A. I. Hanna (2005);
binim2layers.m
bwmergeregions.m
function binmerge = bwmergeregions(I) This is a script that takes a binary image and then merges the seperate regions using a convex hull. Dr. A. I. Hanna (2006).
calcRegionalSectorNumbers.m
function [density, empty_regions] = calcDeficientRegions(T, pts, regions_ind, xydata) Dr. A. I. Hanna (2007)
calcRegionalSectors.m
calcWarpedSpringLength.m
function L = calcWarpedSpringLength(L, s_max, s_min, theta, alpha) Dr. A. I. Hanna 2005.
calc_average_sector_info_for_organ_grid.m
function av_info = calc_average_sector_info_for_organ_grid(organ_grid, grid_ind) Dr. A. I. Hanna (2007)
calc_average_stage_sector_info.m
function [average_sector_info] = calc_average_stage_sector_info(info) This function takes in a cell structure (info) where each element of the cell array corresponds to a region in the organ being analysed. The output parameter, average_sector_info, is a stucture whose length is the same as the number of regions on the organ being analysed. Each element of this structure contains the following Dr. A. I. Hanna (2007)
calc_grid_outline.m
calc_region_corners.m
calc_remove_ind.m
calc_stage_sector_info.m
function [region_info, areas] = calc_stage_sector_info(stage, R, centroids)
A function to get the sector info for a particular stage in a particular
region specified by R.
Input Params:
stage - the path to the stage directory to work on
R - the MxNxR matrix where MxR is the size of the image and R is the
number of regions + 1
centroids - the Qx2 matrix of centroids, NOTE: centroids is of the form [y, x]
Dr. A. I. Hanna (2006)
calc_stage_sector_info_for_trimesh.m
function [region_info, areas] = calc_stage_sector_info_for_trimesh(stage, T, regs, area_thr)
A function to get the sector info for a particular stage in a particular
region specified by R.
Input Params:
stage - the path to the stage directory to work on
R - the MxNxR matrix where MxR is the size of the image and R is the
number of regions + 1
centroids - the Qx2 matrix of centroids, NOTE: centroids is of the form [y, x]
Dr. A. I. Hanna (2006)
calc_strain_cross_matrix.m
function [SCM] = calc_strain_cross_matrix(cpts, cpts_d, REGS) A function that takes two sets of vertices, cpts and cpts_d together with a cell array that has indices to which vertices make up a particular region of the organ. For each region we calculate the best linear transform that takes one set of vertices to the other. We then return a matrix that contains the rotation matrices for each of the regions. Inputs: cpts - before the ungrowth Nx2 matrix cpts_d - after the ungrowth Nx2 matrix REGS - cell array of indices to the vertices for each region Outputs: SCM - a 3x3xR matrix where each 3x3 element is a rotation matrix Dr. A. I. Hanna (2007)
calculate_growth_factors.m
cbar.m
cbar(n, x, MAP)
This function plots a color histogram according to its distance along the
x-axis.
params:- x and n are the result of the hist call
MAP is the desired color map, if not specified jet is used
example:
[x, n] = hist(randn(10000,1), 50);
map = copper(50);
cbar(x, n, map);
axis tight; grid on;
Dr. A. I. Hanna
checkSATDir.m
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Check that the directory is valid, i.e. it has Original and Processed %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
chooseStage.m
function stage_dir = chooseStage A function to allow the user to select the stage they want to process. Only valid for SAT projects. Dr. A. I. Hanna (2006)
cleanup_stage_list.m
[files] = cleanup_stage_list(files) This function takes in a cell array of filenames, from this list it removes the filename '.', '..', and 'Data' as these are reserved names in the 'Staged' Directory of a SectorAnalysisToolbox Project. Dr. A. I. Hanna (2005)
concavitycheck_unused.m
D : dir to check
cost_function_edge.m
function [toterr,erri] =cost_function_edge(xyEdg, nsc, dist) Dr. A. I. Hanna (2005).
cost_function_spring.m
[toterr,erri] = cost_function(S) Dr. A. I. Hanna (2005)
defineAngles.m
show warped image
delaunay_manual.m
deleteSmallRegions.m
function [R, corners] = deleteSmallRegions(R, corners, region_size_threshold)
direction2doubletime.m
display_grid.m
displays the grid using the order from concavity check Dr. A. I. Hanna (2005)
display_growth_factors.m
function [marker_handle, line_handle, text_handle] = display_springs(S,image_axis)
C:\Users\AB\DArT_Toolshed\Toolboxes\SectorAnalysisToolbox\Utilities\display_methods
display_edges.m
[marker_handle, line_handle, text_handle] = display_edges(S,E,image_axis) Display spring mesh
S : spring definition
E : Edge Definition (Actually this is the vertext information)
image_axis : this is the handle to the axis you want to draw to
Returns:
marker_handle : handle to the markers
line_handle : handle to the lines
text_handle : handle to the text
(c)ag rolland2001
re-written: Dr. A. I. Hanna (2005)
display_organ.m
function [organ_shape_handle] = display_organ(xy_regions, image_axis) Dr. A. I. Hanna (2005)
display_shape_springs.m
function [marker_handle, line_handle, text_handle] = display_springs(S,image_axis)
display_springs.m
function [marker_handle, line_handle, text_handle] = display_springs(S,image_axis)
display_organ_shape.m
display_organ_shape(edge_petal, image_axis, color, width) Dr. A. I. Hanna (2005)
distance.m
DISTANCE - computes Euclidean distance matrix
E = distance(A,B)
A - (DxM) matrix
B - (DxN) matrix
Returns:
E - (MxN) Euclidean distances between vectors in A and B
Description :
This fully vectorized (VERY FAST!) m-file computes the
Euclidean distance between two vectors by:
||A-B|| = sqrt ( ||A||^2 + ||B||^2 - 2*A.B )
Example :
A = rand(400,100); B = rand(400,200);
d = distance(A,B);
distmat.m
ellip_vec2struct.m
function [d] = ellip_vec2struct(v) A function to take a vector, v, and convert it to a structure suitable for an ellipse d.Centroid(1) = v(1); d.Centroid(2) = v(2); d.Area = v(3); d.MajorAxisLength = v(4); d.MinorAxisLength = v(5); d.Orientation = v(6);
ellipse_fit2d.m
function [data] = ellipse_fit2d(PC)
This function fits an ellipse to some data given by PC.
Input Params:
PC - this is an Mx2 matrix of x, y coordinates that specify a region
Output Params:
data - this is a structure that contains the information about the ellipse
as follows:
data.Orientation - the principle direction of the ellipse
data.MajorAxisLength - length along the principle direction
data.MinorAxisLength - length along the minor axis
data.Centroid - this is an 1x2 vector of x and y coordinates
data.Area - this is the length of the data 'PC', i.e. the number of
pixels for that sector.
Dr. A. I. Hanna (2006).
ellipse_fit2d_ag.m
E=fit_ellipse(X); Fit best ellipse to set of points.
For set or points X returns E.
X : column of [x y] vectors
E=fit_ellipse(X,Y);
X : vector of x coordinates
Y : vector of y coordinates
Returns
E : [angle;length;width] (angle is in degress)
See also: sector_to_details, regress.
(c) Stephen Impey, 1996
find_bad_triangles.m
find_neighbours.m
function [neighbours] = find_neighbours(R) this function takes in a NxMxP matrix that has P layers. The first layer is the binary image of the whole organ, and the other layers are defined by the grid. This function returns a matrix that is PxP in size, neighbours is an adjacancy graph where each row corresponds to a region and its neighbours, i.e. row 1 is region 1 and any 1s in this row correspond to neighbours. Dr. A. I. Hanna (2005)
find_region.m
function [region_num] = find_region(R, info, centroids) This function takes in a NxMxP matrix, where the P denotes the number of layers in this (mask) matrix. The second parameter info, is a structure for an ellipse. The centroids are the centroids of the regions defined in R. NOTE: that centroids are in the format [y, x] and info.Centroid [x, y] so we flip centroids in here. The function returns the region number that the centroid of info falls in. Dr. A. I. Hanna (2006)
fitGrowthTensor.m
Dr. A. I. Hanna (2007).
flipRGB.m
getAnisotropyColours.m
function C = getAnisotropyColours(anisotropy) A function that takes an Nx1 vector containing the values of anisotropy for a particular region. It returns the colours for those regions as defined in "Growth dynamics underlying petal shape and asymmetry", A. G. Rolland Lagan et. al., Letters to Nature, vol 422, 13th March, 2003. See also: getDoublingTimeColours, growthParameters2GrowthRateAnisotropy Dr. A. I. Hanna (2007)
getDoublingTimeColours.m
function C = getDoublingTimeColours(doubling_time) A function that takes an Nx1 vector containing the values of doubling time for a particular region. It returns the colours for those regions as defined in "Growth dynamics underlying petal shape and asymmetry", A. G. Rolland Lagan et. al., Letters to Nature, vol 422, 13th March, 2003. See also: getAnisotropyColours, growthParameters2GrowthRateAnisotropy Dr. A. I. Hanna (2007) matri=hsv(60);
getEllipColour.m
function col = getEllipColour(area) Dr. A. I. Hanna (2007)
get_centroids.m
get_mean_angle.m
function [theta] = get_mean_angle(angles) This function returns the average angle in radians for the angles given in the vector angles. Dr. A. I. Hanna (2005).
get_parent_dir.m
[parent_dir_name, parent_dir_path] = get_parent_dir(name)
This function takes a name and performs the fileparts operation twice, it
returns (only) the name of the parent directory,
example:
>> get_parent_dir('C:\Documents and Settings\aih\My Documents\post_doc\SectorAnalysisToolbox\SAT_Matlab_files_AIH')
ans =
SectorAnalysisToolbox
Dr. A. I. Hanna (2005)
get_pixel_per_cell_value.m
get_project_segmentation_algorithm.m
get_region_vertices.m
function [x, y] = get_region_vertices(E, S, r); This function takes a region number, the matrix of edges and the springs, and the region number of interest Dr. A. I. Hanna (2005)
get_trans2nd.m
T=get_trans2nd(U,X)
Given two nx2 (n>=6) matrices, U and X defining two polygons
this function returns vector T the a 2nd order polynomial
transformation coefficients.
See also: trans2nd, warp2
See: Digital Image Warping (George Wolberg) page 64.
(c) Stephen Impey, March 1996
getproftc.m
GETPROFTC Get normalised gray level difference profile from START -> END
G = GETPROFTC(IMG,START,END,NPIXELS)
@(#)getproftc.m 1.2 30 Aug 1996
Iain Matthews, UEA, Norwich
getstagefilenames.m
function files = getstagefilenames(stage_dir) A function that returns the files for a given stage. Dr. A. I. Hanna (2006)
growthParameters2GrowthRateAnisotropy.m
function [doubling_time, anisotropy] = growthParameters2GrowthRateAnisotropy(gp, T)
A function thats takes a structure gp with fields, s_max, s_min and
theta. Each of the fields is a Nx1 vector where N denotes the number of
regions for that organ. So for an organ with 12 regions we would have
gp =
s_max: [12x1 double]
s_min: [12x1 double]
theta: [12x1 double]
The other input is T, this denotes the number of hours it takes for the
organ to double in size (default T = 20).
Returns the doubling times and the anisotropy rates for each region.
See also: getDoublingTimeColours, getAnisotropyColours
Dr. A. I. Hanna (2007)
growthParameters2GrowthRates.m
function growthrates = growthParameters2GrowthRates(gp, deltaSt)
A function thats takes a structure gp with fields, s_max, s_min and
theta. Each of the fields is a Nx1 vector where N denotes the number of
regions for that organ. So for an organ with 12 regions we would have
gp =
s_max: [12x1 double]
s_min: [12x1 double]
theta: [12x1 double]
The other input is T, this denotes the number of hours it takes for the
organ to double in size (default T = 20).
Returns the doubling times and the anisotropy rates for each region.
See also: getDoublingTimeColours, getAnisotropyColours
Dr. A. I. Hanna (2007)
growth_rate2colour.m
image_sort.m
IMAGE_SORT Sorts the given data points (pixels of an image)
in the data_ordered array
Usage: [data_ordered]= image_sort(x,y)
Warning:
It is assumed that the nearest pixel is not farther
than sqrt(2^15)=180 pixels
Written and tested in Matlab R14SP1
Date: 01.01.2005
Author: Atakan Varol
email: atakanvarol@su.sabanciuniv.edu
homepage: http://students.sabanciuniv.edu/~atakanvarol/
img_centroid.m
V=img_centroid(X);
Return centre of mass V=[x y] of non-zeros in image matrix X.
If image is all zeros returns V as image centre.
Ensure region in image is flat (equal value).
(c) Stephen Impey, 1996
interp_tri.m
function [tri, vertices] = interp_tri(tri, vertices, iter)
A function to interpolate the triangulation. For each triangle, find the
center and then add this to the set of vertices.
Input Params:
tri - a triangulation e.g. delaunay
vertices - a Mx2 matrix of vertices
iter - the number of iterations to perfrom, (default = 1)
Output Params:
tri - the new triangulation with extra vertices
vertices - the new set of points.
Note: if you want to use this with another set of points, then you had
better warp the interpolation pts to the new frame of reference.
Dr. A. I. Hanna (2006)
interp_vertex_points.m
layers2corners.m
layers2grid.m
layers2vertex_edge.m
load_stage_info.m
load_stage_sector_info.m
function [stage_info] = load_stage_sector_info(stage, arealim) Dr. A. I. Hanna (2006)
make_edge_petal.m
makeobj.m
makeobj2.m
makeorder.m
manual_click_region_pts.m
modify_extension.m
function modify_extension(start_dir, old_ext, new_ext)
Example:
>>modify_extension(pwd, '.jpg', '.JPG'); % this will change all .jpg
% files to .JPG files from pwd down.
Dr. A. I. Hanna (2005)
normim.m
objplot.m
objread.m
orderEdgs.m
order_pts.m
parseArgs.m
Helper function for parsing varargin.
ArgStruct=parseArgs(varargin,ArgStruct[,FlagtypeParams[,Aliases]])
* ArgStruct is the structure full of named arguments with default values.
* Flagtype params is params that don't require a value. (the value will be set to 1 if it is present)
* Aliases can be used to map one argument-name to several argstruct fields
example usage:
--------------
function parseargtest(varargin)
%define the acceptable named arguments and assign default values
Args=struct('Holdaxis',0, ...
'SpacingVertical',0.05,'SpacingHorizontal',0.05, ...
'PaddingLeft',0,'PaddingRight',0,'PaddingTop',0,'PaddingBottom',0, ...
'MarginLeft',.1,'MarginRight',.1,'MarginTop',.1,'MarginBottom',.1, ...
'rows',[],'cols',[]);
%The capital letters define abrreviations.
% Eg. parseargtest('spacingvertical',0) is equivalent to parseargtest('sv',0)
Args=parseArgs(varargin,Args, ... % fill the arg-struct with values entered by the user
{'Holdaxis'}, ... %this argument has no value (flag-type)
{'Spacing' {'sh','sv'}; 'Padding' {'pl','pr','pt','pb'}; 'Margin' {'ml','mr','mt','mb'}});
disp(Args)
% Aslak Grinsted 2003
Overloaded methods:
dataset/parseArgs
plot_ellipse.m
function [eh] = plot_ellipse(axis_handle,r) This function takes an axis handle and a stucture r that contains information about an ellipse. r has structure as follows: r.Orientation r.MajorAxisLength r.MinorAxisLength r.Centroid Uses: plot_ellipse_axis Dr. A. I. Hanna (2005)
plot_ellipse_axis.m
function [ellipse_axis_handle] = plot_ellipse_axis(axis_handle, ellipse_info, color) This function takes an axis handle and a stucture r that contains information about an ellipse. r has structure as follows: r.Orientation r.MajorAxisLength r.MinorAxisLength r.Centroid Used in: plot_ellipse Dr. A. I. Hanna (2006)
plot_raw_sectors.m
plot_region.m
%%%% %%%%%
pmalign.m
pmalign, point model alignment tool [xaligned, ProcrustesAlignment] = pmalign(x, opts); This function takes in the raw point models and then aligns them according to the options in opts. These options are a 1x3 array containing zeros or ones. For example opts = [1 1 1] will align the shapes according the scale, rotation and translation, so the structure of opts is as follows, opts = [toggle_scale, toggle_rotation, toggle_translation]; If you want to align your shapes to make rotations and translations invariant but you want to capture scaling, then use opts = [0 1 1]; The function returns 2 parameters, xaligned which are the aligned shapes, and ProcrustesAlignment which is a 4x1 array of numbers, with the following format ProcrustesAlignment = [scale*cos(theta), scale*sin(theta), trans_x, trans_y]'; It is in this format for compliance with applytrm written by Dr. Barry J. Theobald at the University of East Anglia. If you wish to get back to the origianl points from the aligned points, you simply use the command x_orig = applytrm(x, proc_data); Dr. A. I. Hanna (2005);
pmalign_old.m
pmalign, point model alignment tool
[xaligned, ProcrustesAlignment] = pmalign(x, opts);
This function takes in the raw point models and then aligns them
according to the options in opts. These options are a 1x3 array
containing zeros or ones. For example opts = [1 1 1] will align the
shapes according the scale, rotation and translation, so the structure of
opts is as follows, opts = [toggle_scale, toggle_rotation,
toggle_translation];
If you want to align your shapes to make rotations and translations
invariant but you want to capture scaling, then use opts = [0 1 1];
The function returns 2 parameters, xaligned which are the aligned shapes,
and ProcrustesAlignment which is a 4x1 array of numbers, with the
following format
x, one column per pointmodel (stored, x1,y1,x2,y2 ...)
opts, flags controlling [scale, rotation, translation] 0 for off else 1
Mean, one column representing a pointmodel to which x is to be aligned
(by default pmalign computes the mean x and uses that instead)
xaligned, pointmodes from x that have been aligned together
ProcrustesAlignment = [scale*cos(theta), scale*sin(theta), trans_x,
trans_y]';
It is in this format for compliance with applytrm written by Dr. Barry J.
Theobald at the University of East Anglia.
Dr. A. I. Hanna (2005);
polytransformorder2.m
function [warped_pts] = polytransformorder2(frommarker, tomarker, frompts) Dr. A. I. Hanna (2005)
pts2gridIm.m
range.m
R=range(X,mask);
Find range of values in X contained within mask.
R : [min_value max_value];
(c) Stephen Impey, 1996
Overloaded methods:
qfft/range
range2layers.m
recalc_average_info.m
regions_xy2warping_parameters.m
regs2layers.m
reinit_regions.m
function [Spr,Edgs]=reinitreg(Spr,Edgs2,Rb,opt,rgmore);
function that reinitialises regions as growth/ungrowth proceeds
enables to recalculate distances of one region towrds an other and reset values in springs matrix
possible to save region layers as are calculated here. not saved as not required so far
opt: =1: reinit. all
=0: only recenters centroids
=2: reinit but no recenter centroids
rolland apr 2003
relax_edges.m
relax_edges_NM.m
[S2,toterr]=relax_springs_NM(S,animate, image_axis)
Relax 2D springs in S indexed by n.
uses fmins to minimise error between spring length and equilibrium
spring length. %used fiminunc on siganim2, but does not exist on image14pc so use fminsearch
Finishes when no changes made, or 1000 iterations.
S : 2D spring description
image_axis : handle to the axis where the image shoudl be drawn
Returns:
S2 : relaxed version of S
iter : number of iterations used
See also: make_springs
(c) ag_rolland 2000
re-written Dr. A. I. Hanna (2005)
relax_springs.m
modif 15/11/00 : stiffness changes
modif 28/11/05 : changed a lot of the code to work with the toolbox.
[S2,iter]=relax_springs(S,n,opts) for now agrelax_springs2 not different from version 1.
Relax 2D springs in S indexed by n.
Finishes when no changes made, or 1000 iterations.
S : 2D spring description
n : numbers of springs to relax (default: all)
opts : Options (default: [0 1000])
[verbose max_iterations]
Returns:
S2 : relaxed version of S
iter : number of iterations used
See also: make_springs
(c) Stephen Impey, 1996-7
rolland 1999-2000
Dr. A. I. Hanna (2005)
relax_springs_NM.m
[S2,toterr]=relax_springs_NM(S,animate, image_axis)
Relax 2D springs in S indexed by n.
uses fmins to minimise error between spring length and equilibrium
spring length. %used fiminunc on siganim2, but does not exist on image14pc so use fminsearch
Finishes when no changes made, or 1000 iterations.
S : 2D spring description
image_axis : handle to the axis where the image shoudl be drawn
Returns:
S2 : relaxed version of S
iter : number of iterations used
See also: make_springs
(c) ag_rolland 2000
re-written Dr. A. I. Hanna (2005)
remake_edge_data.m
removeBadRatioFaces.m
removeOutsideFaces.m
function triOut = removeOutsideFaces(tri, points, polygonVertices)
tri, the original triangulation data structure, indexing into
points, the triangulated point cloud.
polygonVertices, the vetex list defining the polygon which may be
concave. The third argument is a subset of the second
argument
triOut, the new triangle list which corresponds to tri with all
the triangles lying outside the polygon specified by
polygonVertices removed
remove_edge_duplicated.m
Remove Duplications from the edge indices
remove_neighbourhood.m
remove_small_regions.m
removebadtriangles.m
rotmat.m
ROTMAT Compute a 2D rotation matrix R=rotmat(phi)
sector_im2struct.m
function [sector_info] = sector_im2struct(sectorsim)
A function that takes a binary image and converts it to a structure array
that contains the ellipse information about the sectors.
Input Params:
sectorsim - a binary image that contains sectors
Output Params:
sector_info - a structure array where each element contains the ellipse
information returned by 'ellipse_fit2d'
Dr. A. I. Hanna (2006)
Uses: ellipse_fit2d
set_pixel_per_cell_value.m
show_aligned_edges.m
function show_aligned_edges Find all the files with name 'edge_aligned_xy.mat' from the current directory down and plots the shape. You can right click on the shapes to display their names Example: show_aligned_edges Dr. A. I. Hanna (2007)
show_average_number_of_sectors.m
show_stage_sector_info(mean_shape_dir, stage_dir) Dr. A. I. Hanna (2005);
show_grid_regions.m
show_average_ellipses_all_stages(mean_shape_dir, stage_dir) Dr. A. I. Hanna (2005);
show_growth_tensor.m
show_layers.m
function show_layers(R) Given a matrix R \in NxMxQ with Q layers this script shows all the layers as different colours. Dr. A. I. Hanna (2005);
show_library_functions.m
function show_library_functions Displays the files in the LibarayFunctions directory for SAToolbox Dr. A. I. Hanna (2007)
show_region_info.m
stage = 'S3'; imagedir = 'A3'; gridname = 'grid_data_5_by_5.mat'; region_number = 1; l = load(['Staged', filesep, stage, filesep, imagedir, filesep, 'RegionData\region_info_', gridname]);
show_region_pts.m
shrink_internal_springs.m
shrink_organ.m
shrink_pts.m
shrink_springs.m
sort_all_region_pts.m
sort_region_pts.m
strlenn.m
%%%%%%%%%%%%%%%%%%%%
s = strlenn(s, n)
This function takes a string s and if the length of s
is greater than n then the string will place ... in the
center to shorten the string.
%%%%%%%%%%%%%%%%%%%%%
subaxis.m
SUBAXIS Create axes in tiled positions. (just like subplot)
Usage:
h=subaxis(rows,cols,cellno[,settings])
h=subaxis(rows,cols,cellx,celly[,settings])
h=subaxis(rows,cols,cellx,celly,spanx,spany[,settings])
SETTINGS: Spacing,SpacingHoriz,SpacingVert
Padding,PaddingRight,PaddingLeft,PaddingTop,PaddingBottom
Margin,MarginRight,MarginLeft,MarginTop,MarginBottom
Holdaxis
all units are relative (e.g from 0 to 1)
Abbreviations of parameters can be used.. (Eg MR instead of MarginRight)
(holdaxis means that it wont delete any axes below.)
Example:
>> subaxis(2,1,1,'SpacingVert',0,'MR',0);
>> imagesc(magic(3))
>> subaxis(2,'p',.02);
>> imagesc(magic(4))
2001 / Aslak Grinsted (Feel free to modify this code.)
trans2nd.m
U=trans2nd(T,X) Perform 2nd order transformation T on column of vectors X
X = [x1 y1; x2 y2; ...; xn yn];
T = [a00 b00; a10 b10; a01 b01; a11 b11; a20 b20; a02 b02];
U=trans2nd(T,X,Y)
Perform 2nd order transformation T on column of vectors (X,Y)
Returns column of vectors U
U = [u1 v1; u2 v2; ...; un vn];
See also: get_trans2nd.m
(c) Stephen Impey, 1997
tri2vec.m
triangulate_manual.m
turn.m
Z=turn(X,A) Turn Vector(s) X through angle A radians clockwise.
X should be a column of vectors.
ie [ x1 y1;
x2 y2;
x3 y3;
: :
xn yn ]
Returns Z, and is of same dimensions as X.
warp_control_pts.m
warp_edges.m
E added for agungrowstep212(to remove later) 04/12/00
uses principal direction of growth
Warp edges in Edg, using region difference in D and centroid of regions
in S.
S : springs warped
D : output from diffregions
Edg : edges info
(c) ag rolland 2000
Dr. A. I. Hanna (2005)
warp_organ_shape.m
function [warped_edge] = warp_organ_shape(Enew, Snew, Eold, Sold, order, edge_petal)
l = load('Staged\Data\UngrowthData\3_1_5_5.mat');
g = load('Staged\Data\Grids\grid_data_5_by_5.mat');
g = g.region_info;
Enew = l.ungrown_grid(2).E;
Snew = l.ungrown_grid(2).S;
Eold = l.ungrown_grid(1).E;
Sold = l.ungrown_grid(1).S;
warp_shape_springs.m
warp_springs.m
function [new_spring_length] = warp_springs(S, ungrowth_tensors) Inputs: S - springs to be warped scaling_factors - the difference in region information Dr. A. I. Hanna 2007
C:\Users\AB\DArT_Toolshed\Toolboxes\SegmentationToolbox
C:\Users\AB\DArT_Toolshed\Toolboxes\SegmentationToolbox\qtMaxFlow
C:\Users\AB\DArT_Toolshed\Toolboxes\SegmentationToolbox\qtMaxFlow\icons
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\3DExtension
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\3DExtension\MCTLibApplicationsJS
alignWithTargetPoints.m
function varargout = alignWithTargetPoints(varargin) Description: Utility function to align a surface and its associated landmarks with a target point set. This function may be used prior to warpSurface to minimise the extend of warping to be performed using MCT Author: Johann Strasser Date: 080114
jsmctj_demo.m
function mctj_demo(id)
A method that demonstrates the use of the motion coherent velocity field
estimation methods. Here we generate
Inputs:
id - 1, 2, 3 (various demos)
Example 1:
mct_demo;
Example 2:
mct_demo('id', 1);
Example 3:
mct_demo('id', 2);
Example 4:
mct_demo('id', 3);
Dr. A. I. Hanna, CMP, UEA, 2008.
motionCoherenceDemo.m
function motionCoherenceDemo(id) Demonstration of AIH motion coherence code (analytical solution). Author: Johann Strasser Date: 080902
motionCoherenceDemo2D.m
function motionCoherenceDemo(id) Demonstration of AIH motion coherence code (analytical) Author: Johann Strasser Date: 081107
plot_vector_field.m
Taken from AIH's mctj_demo.m. Given its own m-file to be available to other functions
warpSurface.m
function varargout = warpSurface(varargin) Description: Warps a surface using AIH implementation of the MCT. Author: Johann Strasser Date: 080114
convertToRealSpace.m
function varargout = convertToRealSpaceTool(varargin) Description: GUI tool to convert image space point models to real space point models based on the voxel size encoded in the point model name Author: Johann Strasser Date: 071218
getCroppedVolumeDirs.m
function volumeDirs = getVolumeDirs(croppedVolumesPath) function to get all the cropped volume directories in a given project's cropped directory. This is required instead of looking for jpg files in the cropped directory as done for the 2D case.
getSurfaceData.m
function varargout = getSurfaceData(varargin) Description: Returns the surface data for visualisation Author: Johann Strasser Date: 080130
getVoxelSizeFromString.m
function varargout = getVoxelsizeFromString(varargin) Description: Given a string, typically a directory- or filename return a vector containing the voxel size as given in the string Author: Johann Strasser Date: 071105
isProject3D.m
function [value] = isProject3D(projectDir) Description: A function to determine whether a project is a 3D project Author: Johann Strasser Date: 070312
newProjectDialog.m
NEWPROJECTDIALOG M-file for newProjectDialog.fig Description: A hardcoded (specific purpose) question dialog. Author: Johann Strasser Date: 070308
normaliseImagesToVoxelSize.m
function normaliseImagesToVoxelSize function normaliseImagesToVoxelSize Utility script to resize images in current directory to reflect a predefined voxel size. The images are assumed to have the voxel size in the file name following the format used for volume directory names. Motivation is to resize screenshots taken from viewVolume to have them to scale. Note that viewVolume normalises to the smallest voxel size on display, hence we use the minima to work out scaling. Note that we assume 3 character extensions. Also not that we have only used this for cubic voxel sizes from OPT screenshots, hence the minimum dimension is the voxel size in x, y and z
scratch.m
template2DTo3D.m
function template2DTo3D()
todemos.m
toex.m
toht.m
tomb.m
toproject.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox
AAMToolbox - Copy.m
function output=AAMToolbox(arg, argoption)
Create or select a Shape Model Project
namely a directory structure called: PRJ_*
arg, usually a string identifying what to do
by default it initialise the GUI
argoption, additional information to be passed between calls
by default it is empty and ignored
output, usually a copy of non-gui data
e.g. AAM, dat
usage:
To launch the toolbox for replaying only
AAMToolbox
To launch the toolbox for model building include your initials
AAMToolbox('Initialise','JAB')
Within the AAMToolbox the string provides a command
AAMToolbox('refresh')
The second argument provides a extra option
Finally,
AAMToolbox(Data) where Data is either
an AAMToolbox structure (prevents AAMToolbox initialising from
disc)
a Class structure in which case it updates the appropriate part of
the AAMToolbox structure (prevents AAMToolbox initialising from
disc)
also see
guide('AAMToolbox.fig'); % to edit the GUI layout
AAMToolbox; % to manage the creation and display of shape and
appearance models
ModelGenerator; % to create/edit statistical models
PMTemplateBuilder; % to create/edit and then select a template from which
create a new set of pointmodels (that will require dotting in)
AAMSetPicker; % to create/edit and then select a subset of points
from a template (i.e. set of pointmodels) from which statistical
models will be built
ModelBuilder; % to create/edit and then select a list of pointmodels
and associated images from which a statistical model is built
UpdateModel; % to ripple changes in template through all derivative
pointmodels
Andrew I Hanna, 2005
(J. Andrew Bangham, 2005)
AAMToolbox.m
function output=AAMToolbox(arg, argoption)
Create or select a Shape Model Project
namely a directory structure called: PRJ_*
arg, usually a string identifying what to do
by default it initialise the GUI
argoption, additional information to be passed between calls
by default it is empty and ignored
output, usually a copy of non-gui data
e.g. AAM, dat
usage:
To launch the toolbox for replaying only
AAMToolbox
To launch the toolbox for model building include your initials
AAMToolbox('Initialise','JAB')
Within the AAMToolbox the string provides a command
AAMToolbox('refresh')
The second argument provides a extra option
Finally,
AAMToolbox(Data) where Data is either
an AAMToolbox structure (prevents AAMToolbox initialising from
disc)
a Class structure in which case it updates the appropriate part of
the AAMToolbox structure (prevents AAMToolbox initialising from
disc)
also see
guide('AAMToolbox.fig'); % to edit the GUI layout
AAMToolbox; % to manage the creation and display of shape and
appearance models
ModelGenerator; % OLD - now crashes Matlab to create/edit statistical models
ModelGeneratorTool; % to create/edit statistical models
PMTemplateBuilder; % to create/edit and then select a template from which
create a new set of pointmodels (that will require dotting in)
AAMSetPicker; % to create/edit and then select a subset of points
from a template (i.e. set of pointmodels) from which statistical
models will be built
ModelBuilder; % to create/edit and then select a list of pointmodels
and associated images from which a statistical model is built
UpdateModel; % to ripple changes in template through all derivative
pointmodels
Andrew I Hanna, 2005
(J. Andrew Bangham, 2005)
AAMToolbox_InstallTest.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\AugmentProjectFunctions
BuildAugmentedPointModels.m
function BuildAugmentedPointModels Dr. A. I. Hanna (2007)
MakeAugmentedTemplate.m
%%%% %%%%%
OrderAugmentedPointModels.m
%%%% %%%%%
findMaxFilesToAugment.m
function N = findMaxFilesToAugment(ordered_pmfiles) Given a set of ordered point model files, it returns the maximum number to read in. Dr. A. I. Hanna (2007)
getAugmentInfo.m
getAugmentedOrderedPMFiles.m
function [ordered_pmfiles, N] = getAugmentedOrderedPMFiles(augmentdir) Given an augmented project data directory it returns the cell structure of the ordered point model files, and the maximum number to read in. It gets the file names from an excel file created when create ordered point models is called. Dr. A. I. Hanna (2007)
getAugmentedSegmentPoints.m
function segmentpoint = getAugmentedSegmentPoints(projdir)
getPMList.m
% %%
scaleAugmentationGroup.m
This is the default directory where we keep general project data
selectTemplate.m
% %%
showScalingInfo.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\AutomaticPlacement
AutomaticPlacement.m
AutomaticPlacementOLD.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\AutomaticPlacement\FromGFtbox
KparKperModel.m
ReadGFtboxMonitor.m
ReadGFtboxMonitor2.m
SavePointModels.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\AutomaticPlacement\NonlinearOptimisation
NonlinearOptimisationFit.m
Initially just get the data
NonlinearOptimisationPlace.m
%%%%%%%%%%%%%%%%%%%%%%% PlaceLandmarksSimple Uses the edge information of the binary image to place landmarks along the boundary
min_ratio.m
PlaceLandmarks.m
%%%%%%%%%%%%%%%%%%%%%%% PlaceLandmarksSimple Uses the edge information of the binary image to place landmarks along the boundary
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\AutomaticPlacement\ProjectiveOptimisation
GetMarkerPoints.m
ProjectiveOptimisationFit.m
ProjectiveOptimisationPlace.m
%%%%%%%%%%%%%%%%%%%%%%% PlaceLandmarksSimple Uses the edge information of the binary image to place landmarks along the boundary
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\AutomaticPlacement\SegmentationAlgorithms
Manuela_RILS_Small_Leaves_Green_on_White.m
Segment_Leaves_Manuela.m
[B, sorted_edge] = SegLeafFromBackground(I);
Input params:
I - the input image
Output params:
B - the binary image
sorted_edge - the edge of the objects in B, ordered.
Dr. A. I. Hanna 2005.
Segment_Leaves_WhiteBackground.m
[B, sorted_edge] = SegLeafFromBackground(I);
Input params:
I - the input image
Output params:
B - the binary image
sorted_edge - the edge of the objects in B, ordered.
Dr. A. I. Hanna 2005.
Segment_Petals_BlackBackground.m
[B, sorted_edge] = SegLeafFromBackground(I);
Input params:
I - the input image
Output params:
B - the binary image
sorted_edge - the edge of the objects in B, ordered.
Dr. A. I. Hanna 2005. (and J.Andrew Bangham 2005)
Segment_Petals_BlueBackground.m
[B, sorted_edge] = SegPetalFromBackground(I);
Input params:
I - the input image
Output params:
B - the binary image
sorted_edge - the edge of the objects in B, ordered.
Dr. A. I. Hanna 2005.
Segment_Petals_BlueBackground_000_Set_version_1.m
[B, sorted_edge] = SegmentPetalFromBackground(I);
Input params:
I - the input image
Output params:
B - the binary image
sorted_edge - the edge of the objects in B, ordered.
Dr. A. I. Hanna 2005.
Segment_Petals_BlueBackground_200_Set_version_1.m
[B, sorted_edge] = SegmentPetalFromBackground(I);
Input params:
I - the input image
Output params:
B - the binary image
sorted_edge - the edge of the objects in B, ordered.
Dr. A. I. Hanna 2005.
Segment_Petals_BlueBackground_200_Set_version_2.m
[B, sorted_edge] = SegmentPetalFromBackground(I);
Input params:
I - the input image
Output params:
B - the binary image
sorted_edge - the edge of the objects in B, ordered.
Dr. A. I. Hanna 2005.
Segment_Red_Petals_BlueBackground.m
[B, sorted_edge] = SegLeafFromBackground(I);
Input params:
I - the input image
Output params:
B - the binary image
sorted_edge - the edge of the objects in B, ordered.
Dr. A. I. Hanna 2005.
drosophila_eye_segmentation_top.m
E = entropyfile(I); S = stdfilt(I, nhood); R = rangefilt(I, ones(5)); Ic = imcrop(I);
drosophila_eye_segmentation_top_old.m
E = entropyfile(I); S = stdfilt(I, nhood); R = rangefilt(I, ones(5)); Ic = imcrop(I);
segment_arabidopsis_green_on_white_sandra.m
function [w, orig, im, bim, S2] = segment_arabidopsis_green_on_white_sandra(I, w) A function that takes an image and a handle to a waitbar and returns the waitbar handle, the original image, the image with the sectors overlayed, the binary image of the organ, and the binary image of the sectors. This script has been written for Sandra Bensmihen (JIC) for use with the expression of a cell autonomous marker (anthocyanin) in Antirrhinum majus leaves. Dr. A. I. Hanna (2006)
segment_katrin_white_on_black.m
ulises_vein.m
function [w, orig, im, bim, S2] = segment_arabidopsis_green_on_white_sandra(I, w) A function that takes an image and a handle to a waitbar and returns the waitbar handle, the original image, the image with the sectors overlayed, the binary image of the organ, and the binary image of the sectors. This script has been written for Sandra Bensmihen (JIC) for use with the expression of a cell autonomous marker (anthocyanin) in Antirrhinum majus leaves. Dr. A. I. Hanna (2006)
normim.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\BuildSFAM
CheckPMexist.m
re-afirm the list of image files
imagelist=[];
files = dir([ImagesDir, filesep, '*.jpg']);
InputFilenames = {files.name};
%for i=1:size(InputFilenames,1)
for i=1:length(InputFilenames)
imagename=dir([InputDirectory,deblank(InputFilenames{i})]);
%imagename=dir([InputDirectory,deblank(InputFilenames(i,:))]);
if ~isempty(imagename)
% imagelist=strvcat(imagelist,InputFilenames(i,:));
imagelist=strvcat(imagelist,InputFilenames{i});
end
end
filenames=[];
imagelist4=[];
k=0;
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\BuildSFAM\TPS_WarpFcn
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\BuildSFAM\TPS_WarpFcn\MatlabTPS
K_mat.m
L_mat.m
P_mat.m
TPS_im_warp.m
function [wimg, w, a] = TPS_im_warp(img, ipts, opts) This function implements the THIN PLATE SPLINE method of image warping. Input Params: img - the image to be warped ipts - the set of input pts that the image is to be warped to opts - the set of input pts that the image is already registered to Dr. A. I. Hanna (2006).
TPS_pts_warp.m
function [wpts] = TPS_pts_warp(pts, ipts, opts) This function implements the THIN PLATE SPLINE method of point warping. Input Params: pts - the set of points to be warped ipts - the set of input pts that the image is to be warped to opts - the set of input pts that the image is already registered to Dr. A. I. Hanna (2006).
U_rbs.m
function [U_r] = U_rbs(r) This function is a radial basis function used in thin-plate spline parameter estimation. see also: find_tps_params Dr. A. I. Hanna (2005)
matdistance.m
matdistance - the Euclidean distance matrix x = rand(100, 2); y = rand(100, 2); d = matdistance(x,y)
psi_tps.m
function [tps] = psi_tps(u, a, w, opts) This function is the approximate warping function given by the thin plate spline method. Input Params: u - the set of points you wish to warp a, w - the parameters from pts2TPS_param opts - the set of points that you are warping to Output Params: tps - a Mx2 matrix of points defined by the warping function. Dr. A. I. Hanna (2006).
pts2TPS_param.m
function [w, a, K] = pts2TPS_param(ipts, opts) This function calculates the parameters needed in the thin plate spline method. Input params: ipts - the set of base points for an image; opts - the set of points you want to warp an image to Output Params: w, a - parameters used by psi_tps K - the Euclidean distance matrix used by the radial basis function. Dr A. I. Hanna (2006).
tpswarp_c.m
applytrm.m
APPLYTRM transform X by parameters in P
XP = APPLYTRM(X,P) rotates, scales and translates X
by applying the transformation matrix P where,
P(1) = s * cos(theta)
P(2) = s * sin(theta)
P(3) = tx
P(4) = ty
Barry-John Theobald, b.theobald@uea.ac.uk
School of Information Systems, University of East Anglia,
Norwich, NR4 7TJ, UK
Version 1.0
buildsfam.m
BUILDSFAM builds a shape-free appearance model [SFAM, OPTIONS] = BUILDSFAM(OPTIONS,NPIX,V, VERB) builds a shape-free model of appearance given a labelled set of images. OPTIONS is a set of options given by SOPTIONS and NPIX is the (approximate) number of pixels to include in the model. V defines the percentage variance the model should retain (default 0.95 corresponding to 95%). VERB indicates whether the warped images are displayed. NOTE: At present, there is no image normalisation - this still need to be implemented! This is a cutdown version of sfaload.m from Matthews appearance model toolbox, adapted to use the options from soptions, and handle movies as input. Could later write a script to convert the options filenames to a filespec and use the appearance code - must then ensure the directories are correct etc! Barry-John Theobald, b.theobald@uea.ac.uk School of Information Systems, University of East Anglia, Norwich, NR4 7TJ, UK Version 1.2
calctrm.m
CALCTRM calculate the transform parameters to align two shapes P = CALCTRM(S1,S2,W) calculates the translation, scale and rotation to align shape S2 with S1. W is a set of weights giving the relative stability of each data point. See also PDMBUILD APPLYTRM Barry-John Theobald, b.theobald@uea.ac.uk School of Information Systems, University of East Anglia, Norwich, NR4 7TJ, UK Version 1.0
get_options.m
GET_OPTIONS load and check an options structure [OPTS, MSG] = GET_OPTIONS(TYPE, OPTS) loads an options structure and checks the validity of the file. If a structure is given, this is useful to check it is a valid options structure. The options are returned in OPTS and MSG reports the error encountered when checking the file. Barry-John Theobald, b.theobald@uea.ac.uk School of Information Systems, University of East Anglia, Norwich, NR4 7TJ, UK Version 1.0
get_pdm.m
GET_PDM load and check a point distribution model [PDM, MSG] = GET_PDM(FNAME) loads a point distribution model and checks the validity of the file. If a structure is given, this is useful to check it is a valid point distribution model. The point distribution model is returned in PDM and MSG contains any errors encountered when opening, or checking the file. The optional output is the path to and name of the PDM file loaded. Copyright (c), Barry-John Theobald, b.theobald@uea.ac.uk School of Information Systems, University of East Anglia, Norwich, NR4 7TJ, UK Version 1.1
recursive_covariance.m
function recursive_covariance
A script that employs an adaptive update of the mean and covariance
matrix,.
%First set up the image
figh = figure(1); clf;
I = zeros(256, 256);
B1 = roipoly(I);
clf(figh);
% get the xy values of the image patch
[yind, xind] = find(B1);
% this is the actual covariance matrix.
real_R = cov([xind, yind]);
real_mu = mean([xind, yind])';
sse_r = zeros(length(xind), 1);
sse_mu = zeros(length(xind), 1);
% Initialize the covariance and mean
R = zeros(2,2);
mu = zeros(2,1);
% this k denotes the sample number, so we could imagine having another for loop where
% k would not start at 1.
k =1;
for i=1:length(xind)
x = [xind(i); yind(i)];
[R, mu] = recursive_covariance(x, R, mu, k);
k = k+1;
sse_r(i) = sum(sum((R - real_R).^2));
sse_mu(i) = sum((mu - real_mu).^2);
end
figure(figh);
subplot(2,1,1);
plot(sse_r);
grid on;
axis tight;
title('Covariance error');
subplot(2,1,2);
plot(sse_mu);
grid on;
axis tight;
title('Mean error');
axis tight;
Dr. A. I. Hanna (2007)
triwarp.m
TRIWARP Use OpenGL to warp an image WIMG = TRIWARP(IMG,IPTS,OPTS,TRI,VERB) warps the image IMG from the input points IPTS to the output OPTS. The points are (x,y) pairs where each row in the input points corresponds to the same point in the output points. The coordinates must be offset so they exist in the OpenGL coordinate space, i.e. (0, 0) is the first pixel, corresponding to (1, 1) in Matlab. TRI is a list of triples of indicies of the points forming the vertices forming the given triangle. If none are given, the delaunay of the input points is used. Returns a 24-bit RGB uint8 image. e.g. wimg = triwarp(img,ipts-1,opts-1,[],0); Version 1.0
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\BuildSFAM\triwarp_source_code
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\BuildSFAM\triwarp_source_code\gl
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\BuildSFAM\triwarp_source_code\gl-libs32
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\BuildSFAM\triwarp_source_code\gl-libs64
test_gltriwarp.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\CLASSFILES
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\CLASSFILES\@AAM
AAM.m
aam_pca.m
--- help for AAM/aam_pca ---
function [Xm, P, b, pcaDat] = aam_pca(AAM, indices, filenames,FractionPCs, meanshape, in_context_flag, lda_shape_flag) Dr. A. I. Hanna (2006)
add_element.m
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
get_element.m
get_names_with_pm.m
--- help for AAM/get_names_with_pm ---
%%%%%%%%%%%%%%%%%%%% Verify Image List is consistent with point model list %%%%%%%%%%%%%%%%%%%%%
length.m
LENGTH Length of vector. LENGTH(X) returns the length of vector X. It is equivalent to MAX(SIZE(X)) for non-empty arrays and 0 for empty ones. See also NUMEL.
Overloaded methods:
timer/length
serial/length
tscollection/length
daqdevice/length
daqchild/length
distributed/length
codistributed/length
Composite/length
gpuArray/length
qfft/length
videosource/length
videoinput/length
visa/length
udp/length
tcpip/length
icgroup/length
icdevice/length
i2c/length
gpib/length
Bluetooth/length
dataset/length
categorical/length
Reference page in Help browser
doc length
pca.m
PCA Principal Component Analysis (PCA) on raw data.
COEFF = PCA(X) returns the principal component coefficients for the N
by P data matrix X. Rows of X correspond to observations and columns to
variables. Each column of COEFF contains coefficients for one principal
component. The columns are in descending order in terms of component
variance (LATENT). PCA, by default, centers the data and uses the
singular value decomposition algorithm. For the non-default options,
use the name/value pair arguments.
[COEFF, SCORE] = PCA(X) returns the principal component score, which is
the representation of X in the principal component space. Rows of SCORE
correspond to observations, columns to components. The centered data
can be reconstructed by SCORE*COEFF'.
[COEFF, SCORE, LATENT] = PCA(X) returns the principal component
variances, i.e., the eigenvalues of the covariance matrix of X, in
LATENT.
[COEFF, SCORE, LATENT, TSQUARED] = PCA(X) returns Hotelling's T-squared
statistic for each observation in X. PCA uses all principal components
to compute the TSQUARED (computes in the full space) even when fewer
components are requested (see the 'NumComponents' option below). For
TSQUARED in the reduced space, use MAHAL(SCORE,SCORE).
[COEFF, SCORE, LATENT, TSQUARED, EXPLAINED] = PCA(X) returns a vector
containing the percentage of the total variance explained by each
principal component.
[...] = PCA(..., 'PARAM1',val1, 'PARAM2',val2, ...) specifies optional
parameter name/value pairs to control the computation and handling of
special data types. Parameters are:
'Algorithm' - Algorithm that PCA uses to perform the principal
component analysis. Choices are:
'svd' - Singular Value Decomposition of X (the default).
'eig' - Eigenvalue Decomposition of the covariance matrix. It
is faster than SVD when N is greater than P, but less
accurate because the condition number of the covariance
is the square of the condition number of X.
'Centered' - Indicator for centering the columns of X. Choices are:
true - The default. PCA centers X by subtracting off column
means before computing SVD or EIG. If X contains NaN
missing values, NANMEAN is used to find the mean with
any data available.
false - PCA does not center the data. In this case, the original
data X can be reconstructed by X = SCORE*COEFF'.
'Economy' - Indicator for economy size output, when D the degrees of
freedom is smaller than P. D, is equal to M-1, if data
is centered and M otherwise. M is the number of rows
without any NaNs if you use 'Rows', 'complete'; or the
number of rows without any NaNs in the column pair that
has the maximum number of rows without NaNs if you use
'Rows', 'pairwise'. When D < P, SCORE(:,D+1:P) and
LATENT(D+1:P) are necessarily zero, and the columns of
COEFF(:,D+1:P) define directions that are orthogonal to
X. Choices are:
true - This is the default. PCA returns only the first D
elements of LATENT and the corresponding columns of
COEFF and SCORE. This can be significantly faster when P
is much larger than D.
false - PCA returns all elements of LATENT. Columns of COEFF and
SCORE corresponding to zero elements in LATENT are
zeros.
'NumComponents' - The number of components desired, specified as a
scalar integer K satisfying 0 < K <= P. When specified,
PCA returns the first K columns of COEFF and SCORE.
'Rows' - Action to take when the data matrix X contains NaN
values. Choices are:
'complete' - The default action. Observations with NaN values
are removed before calculation. Rows of NaNs are
inserted back into SCORE at the corresponding
location.
'pairwise' - This option only applies when 'eig' method is used.
If specified, PCA switches 'Algorithm' to 'eig'. The
(I,J) element of the covariance matrix is computed
using rows with no NaN values in columns I or J of
X. Please note that the resulting covariance matrix
may not be positive definite. In that case, PCA
terminates with an error message.
'all' - X is expected to have no missing values. All data
are used, and execution will be terminated if NaN is
found.
'Weights' - Observation weights, a vector of length N containing all
positive elements.
'VariableWeights' - Variable weights. Choices are:
- a vector of length P containing all positive elements.
- the string 'variance'. The variable weights are the inverse of
sample variance. If 'Centered' is set true at the same time,
the data matrix X is centered and standardized. In this case,
PCA returns the principal components based on the correlation
matrix.
Example:
load hald;
[coeff, score, latent, tsquared, explained] = pca(ingredients);
See also PCACOV, PCARES, BIPLOT, BARTTEST, CANONCORR, FACTORAN,
ROTATEFACTORS.
References:
[1] Jolliffe, I.T. Principal Component Analysis, 2nd ed., Springer,
2002.
[2] Krzanowski, W.J., Principles of Multivariate Analysis, Oxford
University Press, 1988.
[3] Seber, G.A.F., Multivariate Observations, Wiley, 1984.
[4] Jackson, J.E., A User's Guide to Principal Components, Wiley,
1988.
Reference page in Help browser
doc pca
pca_in_context.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\CLASSFILES\@AAM\private
procrustes.m
PROCRUSTES Perform Procrustes analysis on landmark data
[procdata,theta]=procrustes(data,templ)
[procdata,theta,templ]=procrustes(data)
The second version estimates a template.
data(i).marks = 2D landmarks, 2-by-p matrices
procdata(i).marks = landmarks aligned to a template, 2-by-p matrices
theta = Global transformation parameters,
theta(i).transl = translation
theta(i).phi = rotation
theta(i).scale = scale
read_in_pointmodels.m
--- help for AAM/read_in_pointmodels ---
function aam=read_in_pointmodels(aam, is3D) Dr. A. I. Hanna (2007)
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
set_element.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\CLASSFILES\@AAM_Element
AAM_Element.m
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
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
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\CLASSFILES\@PointModelTemplate
PointModelTemplate.m
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
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
CloseAAMtoolbox.m
Copy of pdmwalk.m
PDMWALK GUI to 'walk' a PDM through each mode of variation PDMWALK(1,'MODEL_PDM') will read from a PDM the file 'MODEL_PDM', PDMWALK(1,pdm) will use the PDM struct (pdm.Xm, pdm.P and pdm.b), PDMWALK will prompt for a file. cd 'C:\Documents and Settings\ab\My Documents\Matlab2004\Nicolas\Images\Modigliani2\ModelData' See also buildpdm Iain Matthews, UEA, Norwich J. Andrew Bangham, UEA 2005
CustomListDlg.m
%%%%%%%%%%%%%%%%%%%%%%%%%%% function selectedFilenames = CustomListDlg(arg) Description: A custom built list dialog that allows the user to specify a regular expression to filter the filenames. Dr. A. I. Hanna (2005)
DiscoverPointSets.m
function AllPointSets=DiscoverPointSets(modelDirec) work through the StatisticalModels directory finding subdirectories associated with each model template and within these finding the sets of models and within each of these use the indices.mat and LN_*.mat files to capture the subset of points AllPointSets, structure array of set names and indices J. Andrew Bangham, 2010
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\DrawingMethods
aamdisp_plotEdges.m
function varargout = aamdisp_plotEdges(varargin) Dr. A. I. Hanna (2007)
plotPointModel.m
plotTemplate.m
ExtractIndices.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\FigureCreator
FigureCreator.m
function FigureCreator(varargin) Example 1: FigureCreator; Example 2: FigureCreator(<your_model_directory>); Dr. A. I. Hanna (2007) CMP, UEA.
FindFilenames.m
function filenames=FindFilenames(partname,startpath)
partname, string that is part or all of the file to be found
e.g. '.mat' or '_pm' (Case sensitive)
startpath, directory from which the path is to be started
default is pwd
dirconstraints, cell array of strings giving a set of directory
name constraints, e.g.
[{'PRJ_'},{'StatisticalModels'},{template}]
filenames, cell array containing path\files (as fullfile)
found recursively
J.Andrew Bangham, 2005
FindSets.m
%%%%%%%%%%%%%%%%%% Find Existing Sets %%%%%%%%%%%%%%%%%%%
GetInteriorPoints.m
GetInterirorPoints.m
HierarchyBuilder.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\IOMethods
aamio_choosePointModelFilenames.m
function varargout = aamio_choosePointModelFilenames Dr. A. I. Hanna (2007)
aamio_getGroupPointModels.m
function [varargout] = aamio_getGroupPointModels(varargin) Dr. A. I. Hanna (2007)
aamio_loadModel.m
function varargout = aamio_loadModel(varargin) Dr. A. I. Hanna (2007)
aamio_loadPointModel.m
function varargout = aamio_loadPointModel(varargin) Dr. A. I. Hanna (2007)
aamio_loadPointModels.m
function varargout = aamio_loadPointModels(varargin) Dr. A. I. Hanna (2007)
aamlib_calcDiffProjError.m
function [ratio, OD, OP] = aamlib_calcDiffProjError(varargin) [ratio, OD, OP] = aamlib_calcDiffProjError; Dr. A. I. Hanna (2007)
aamlib_calcPMError.m
function mse = aamlib_calcPMError(varargin)
mse = aamlib_calcPMError('verbose', 1);
Dr. A. I. Hanna (2007)
aamlib_calcProjError.m
function [ratio, D, projD] = aamlib_calcProjError(varargin)
[ratio, D, projD] = aamlib_calcProjError('verbose', 1);
Dr. A. I. Hanna (2007)
aamlib_gaussianClassifier.m
function [varargout] = ammlib_groupClassifier(varargin) Dr. A. I. Hanna (2007)
aamlib_knnClassifier.m
function [varargout] = aamlib_knnClassifier(varargin) Dr. A. I. Hanna (2007)
aamlib_parzenGaussianClassifier.m
function [varargout] = aamlib_parzenGaussianClassifier(varargin) Dr. A. I. Hanna (2007)
aamlib_pointModelMSE.m
function mse = aamlib_pointModelMSE(varargin)
mse = aamlib_pointModelMSE('verbose', 1);
Dr. A. I. Hanna (2007)
ammlib_groupClassifier.m
function [varargout] = ammlib_groupClassifier(varargin) Dr. A. I. Hanna (2007)
group_test.m
loadTemplate.m
function varargout = loadTemplate(varargin)
I/O method for toolbox AAMToolbox for loading template files
Example:
loadTemplate;
Example:
loadTemplate('filename', 'template.temp_dat');
Dr. A. I. Hanna (2007)
ImportList.m
find all pre-defined sets that are consistent with the current template template, current template name, e.g. Faces11 lists, cell array of set names that contribute to the indices indices, union of indices chosen importable_sets, cell array of compatible point sets created using SetPicker edit_sets, cell array of sets defined by, e.g. Faces11_place_fixed_points.m J.Andrew Bangham, 2005
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\LibraryFunctions
Copy of warp_to_mean_shape.m
function img2=warp_to_mean_shape(pts,ompts,img,indices);
pts, pointmodel from file (one column, x;y;x;y;...)
ompts, mean shape model points (two columns x,y;x,y;...)
img, image to be warped rgb
indices, indices of points to be used for the model
img2, image warped to mean shape (usually much smaller than img)
NaN is used to indicate triangles that have expanded to a
point that makes the pixels unreliable
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\LibraryFunctions\Modified getsfam
getsfam.m
function [sfam, options] = getsfam(image_folder, pt_model_folder, resolution, scale, rotate, trans, v, triangulation)
Input Parameters
image_folder - the location of your images (probably Cropped)
pt_model_folder - the folder containing your point models, _pt.mat
resolution - the number of pixels you want to include in the
appearance model
scale - include scale into the procrustes
rotation - include rotation into the procrustes
translation - include translation into the procrustes
v - the amount of variance to be captured.
Output Parameters:
sfam - the shape and appearance structure
options - the options file used to build the models.
Example:
[sfam, options] = getsfam('Cropped', 'PointModels\PetalTempalte1', 200, 1, 1, 1, .95, []);
Dr. A. I. Hanna (2005)
MutantWildTypeError.m
function MutantWildTypeError This function was written for a paper with S. Bensmihen. The user first selects a model, then they selected the point model file that corresponds to a mean mutant shape. They then selected the point model for the mean wild type (WT) shape. The script calculates the error between the observed mean shape and the observed mean WT. It then calculates the error between the observed mean shape and a reconstructed mean shape using the selected PCs from the model. Dr. A. I. Hanna (2007)
aamlib_scaleImagesAndPointModelsInProject.m
function aamlib_scaleImagesAndPointModelsInProject This function allows the user to rescale the images and the point models for a particular project. This function is not available from the GUI for safety reasons. To explain the reason for this method, there is an example of how to use it below: Suppose we have two projects PRJ_080516_All_species_FP-2-Max10 (images at 60pix/cm) and PRJ_species FP changed (images at 240pix/cm). To make the two projects comparable or to merge the two projects we need to scale the images and point models in the first project by a factor of 4. To do this we make a new project called PRJ_080516_All_species_FP-2-Max10_240pxpcm (images at 240pix/cm) where pxpcm denotes pix/cm. To make this new project we first copied the original project PRJ_080516_All_species_FP-2-Max10 using explorer and renamed it to PRJ_080516_All_species_FP-2-Max10_240pxpcm then in Matlab we changed directory to PRJ_080516_All_species_FP-2-Max10_240pxpcm and at the Matlab prompt typed: >>aamlib_scaleImagesAndPointModelsInProject this changed the size of the images and the point models in project. NOTE: THIS DID NOT CHANGE THE TEMPLATE AT ALL Dr. A. I. Hanna, CMP, 2008
constructAPPPCInfoSheet.m
constructGenInfoSheet.m
constructPCInfoSheet.m
constructPMInfoSheet.m
constructShapePCInfoSheet.m
constructSheet1.m
constructSheet2.m
constructSheet3.m
exportModelData.m
export_eigen_data.m
function export_eigen_data(pdm) A function that takes a pdm structure and saves the eigenvectors and eigenvalues to an excel sheet. In the excel file the sheets that contain the eigenvectors, each column is a vector. Dr. A. I. Hanna (2007)
get_mean_shape_from_model.m
[Xm] = get_mean_shape_from_model(model_str)
Parameters :
Input -
model_str - this is a string pointing to the model.aam_dat that
stores the mean shape data
Ouptput -
Xm - this is a 2xN matrix where Xm(1,:) are the x coordinates and
Xm(2,:) are the y coordinates
Example:
mean_shape = get_mean_shape_from_model('StatisticalModels/LeafTemplate_boundary_02/Set_1/ImageList_1/model.aam_dat');
plot(mean_shape(1,:), mean_shape(2,:),'.');
axis image;
Dr. A. I. Hanna (2005)
getsfam.m
function [sfam, options] = getsfam(image_folder, pt_model_folder, resolution, scale, rotate, trans, v, triangulation)
Input Parameters
image_folder - the location of your images (probably Cropped)
pt_model_folder - the folder containing your point models, _pt.mat
resolution - the number of pixels you want to include in the
appearance model
scale - include scale into the procrustes
rotation - include rotation into the procrustes
translation - include translation into the procrustes
v - the amount of variance to be captured.
Output Parameters:
sfam - the shape and appearance structure
options - the options file used to build the models.
Example:
[sfam, options] = getsfam('Cropped', 'PointModels\PetalTempalte1', 200, 1, 1, 1, .95, []);
Dr. A. I. Hanna (2005)
interpolate_pts_in_triangle_centres.m
%%%%%%% %%%%%%%%start Andy H. Instead of interpolating along edges, interpolate center of triangles.
plot_shape.m
tri_interp_pts.m
function [ipts,opts] = tri_interp_pts(ipts,opts)
A function that makes a triangulation of some input points and then finds
the center of each of these triangles. A linear conformal warp is set up
between the input points and the output points that is dependent on the
trianglulation. The new centers are then warped according to this warp
giving new output points.
Input Params:
ipts - a Mx2 matrix of input points (this will be the one we do the
triangulation on.
opts - a Mx2 matrix of output points
Output Params:
ipts - the interpolated input points
opts - the interpolated output points
Dr. A. I. Hanna (2006).
variance_analyser.m
function varargout = variance_analyser(varargin)
This function calculates the cumulative variance for original and
projected shapes. In this way we can somehow define how much of the
variance of the data is captured after the projection.
Inputs:
DATA - a matrix NxM where the columns represent the dimensions and the
rows are samples (i.e. 100x2 for a 100 2D shapes).
EIGENVECTORS - the rows of this matrix correspond to the eigenvectors to
use to project. The first column is associated with the highest
eigenvalue. See PCA for details.
METHOD - either 'Euclidean' or 'Mahalanobis'. This determines how to
calculate the distance of each sample from the mean, i.e. its deviation.
Outputs:
Vo - variance of the original data with respect to the mean
Vp - variance of the projected data with respect to the mean
Xp - the projected data
Example:
%Some zero centered 3D data
X = randn(100,3);
X(:,3) = X(:,1) + randn(size(X(:,1)))/50;
X = X - ones(size(X, 1),1)*mean(X,1);
% Get the eigenvalues of the covariance matrix
[V, L] = eig(cov(X));
L = diag(L);
[val, ind] = sort(L, 'descend');
L = L(ind);
V = V(:, ind);
% Take the 2 with most variance.
P = V(:,1:2);
[v_m_o, v_m_p, xmp] = variance_analyser('Data', X, 'eigenvectors', P, 'method', 'mahalanobis');
[v_e_o, v_e_p, xep] = variance_analyser('Data', X, 'eigenvectors', P, 'method', 'euclidean');
v_m_r = v_m_p./v_m_o
v_e_r = v_e_p./v_e_o
figure(1); clf;
hold on;
plot_shape('pts', xmp, 'color', [0 0 1]);
plot_shape('pts', X, 'color', [1 0 0]);
Dr. A. I. Hanna (2005) CMP, UEA, 2006.
warp_to_mean_shape.m
function img2=warp_to_mean_shape(pts,ompts,img,indices);
pts, pointmodel from file (one column, x;y;x;y;...)
ompts, mean shape model points (two columns x,y;x,y;...)
img, image to be warped rgb
indices, indices of points to be used for the model
img2, image warped to mean shape (usually much smaller than img)
NaN is used to indicate triangles that have expanded to a
point that makes the pixels unreliable
warp_to_mean_shape_old.m
function img2=warp_to_mean_shape(pts,ompts,img,indices);
pts, pointmodel from file (one column, x;y;x;y;...)
ompts, mean shape model points (two columns x,y;x,y;...)
img, image to be warped rgb
indices, indices of points to be used for the model
img2, image warped to mean shape (usually much smaller than img)
NaN is used to indicate triangles that have expanded to a
point that makes the pixels unreliable
warp_to_mean_shape_old2.m
function img2=warp_to_mean_shape(pts,ompts,img,indices);
pts, pointmodel from file (one column, x;y;x;y;...)
ompts, mean shape model points (two columns x,y;x,y;...)
img, image to be warped rgb
indices, indices of points to be used for the model
img2, image warped to mean shape (usually much smaller than img)
NaN is used to indicate triangles that have expanded to a
point that makes the pixels unreliable
LoadDataFromDisk.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\MaskMaker
MaskMaker.m
Dr. A. I. Hanna (2005) CMP, UEA, 2005.
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\ModelBuilderTool
ModelBuilder.m
builds the point models (statistical models are build using ModelGeneratorTool)
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\ModelGeneratorTool
ModelGenerator.m
ModelGeneratorTool.m
Dr. A. I. Hanna (2005) CMP, UEA, 2006. generates statistical models using PCA from point models
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\ModelViewer
ModelViewer.m
Dr. A. I. Hanna (2005) CMP, UEA, 2005.
ModelViewer_bkjs_20081210.m
Dr. A. I. Hanna (2005) CMP, UEA, 2005.
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\OrganizeAugmentedShapes
OrganizeAugmentedShapes.m
Dr. A. I. Hanna (2006) CMP, UEA, 2006.
PDMWalk_PlotModel.m
Plot model
PDMWalk_ShowModel.m
PDMWalk_show_and_plot.m
PlotFaceOutline.m
PlotModel.m
ProjectListDlg.m
%%%%%%%%%%%%%%%%%%%%%%%%%%% function selectedFilenames = CustomListDlg(arg) Description: A custom built list dialog that allows the user to specify a regular expression to filter the filenames. Dr. A. I. Hanna (2005)
SaveTemplate.m
SetPicker.m
function DataMain=SetPicker(arg)
This program is a bit of a shambles - it has never been used in anger and so never got refined
It is designed to do two things
1) to allow the user to select subsets of the points in the pointmodel template and give them logical names
this data is stored in the template directory with the suffix .edit_sets and prefix of the template name.
Within the SetPicker GUI, these names and associated lists of indices appear in a drop down list.
This data also appears to be stored in the AAMToolbox data structure: DataMain.handles.dat in the fields
and the SetPicker data structure Data
Data.handles.dat.pointSetNumber=pointSetNumber; % index to the current AAM subdirectory (see 2 below)
Data.handles.dat.AllPointSets=EditSetNames; % names of all the subsets
Data.handles.dat.EditIndices=EditIndices; % associated indexes
Data.handles.dat.EditSetNum=EditSetNum; % index to the subset currently selected in the SetPicker dropdown
Data.handles.dat.edit_sets_filename=edit_sets_filename; % fullname of edit_sets file
2) to allow the user to select a named subset from the dropdown list and create a new AAM model directory in the
hierachy: StatisticalModels:Templatename:Set_* which will contains
indices.mat: the subset index list
LN_name.mat: the logical name
The statistical modelling tool will then create subdirectories for each image list and associated model
Imagelist_*: which contains a list of images and the associated statistical models
SaveToDropdownList
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\ShapeSpaceTool
PointCloudProcessor.m
function [] = PointCloudProcessor(arg,option)
Usage:
>> PointCloudProcessor('init');
This function displays point clouds in 3D and then fits a polynomial
function to the cloud. Additionally, you can wrap a 4D surface around the
cloud which is visualised by level surfaces.
Dr. A. I. Hanna (2005)
ShapeSpaceTool.m
Dr. A. I. Hanna (2005) CMP, UEA, 2006.
VectorWalker.m
Dr. A. I. Hanna (2005) CMP, UEA, 2006.
VectorWalker_bkjs_20081211.m
Dr. A. I. Hanna (2005) CMP, UEA, 2006.
aamlib_pm_classifier.m
function aamlib_pm_classifier This function is used to write an excel file that contains the classification of point models against selected groups. The user has to first select the groups to classify against, then they have to pick the groups whose elements they want to classify. Dr. A. I. Hanna (2007)
ShowDetails.m
if strcmp(arg, 'init')
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\ShowEllipseWalk
ShowEllipseWalk.m
Dr. A. I. Hanna (2005) CMP, UEA, 2006.
showVarianceEllipseWithAxes.m
function varargout = showVarianceEllipseWithAxes(varargin)
A plotting routine that displays an ellipsoid for a particular variance
together with its axes.
Default params:
variances = [1 2 3];
xaxiscol = 'm';
yaxiscol = 'c';
zaxiscol = 'y';
axiswidth = 1;
ellipcenter = [0 0 0];
color = [132 132 255]/255;
axish = [];
std_lim =2;
Example:
h = showVarianceEllipseWithAxes;
Example:
h = showVarianceEllipseWithAxes('variances', [1 2 3]);
Dr. A. I. Hanna (2007)
show_app_ellipsoid_walk.m
show_app_ellipsoid_walk('model_dir', 'StatisticalModels\1239_III\Set_1\ImageList_2\', 'stepsize', 0.2);
Default params
movie_dir = ;
appPC = [1 2 3];
stepsize = .1;
pdm = [];
sfam = [];
model_dir = ;
Dr. A. I. Hanna (2007)
show_shape_ellipsoid_walk.m
show_shape_ellipsoid_walk('model_dir', 'StatisticalModels\1239_III\Set_1\ImageList_2\', 'stepsize', 0.2);
Default params
movie_dir = ;
shapePC = [1 2 3];
stepsize = .1;
pdm = [];
sfam = [];
model_dir = ;
Dr. A. I. Hanna (2007)
SmoothLandmarks.m
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% SmoothLandmarks //Smooths the secondary landmarks in a given loop %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\TemplateEditorTool
PMTemplateBuilder.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\ToolsUsingVolViewer
MSRshow.m
function MSRshow(MSR,AxesH)
plot (or delete) 3D data from an MSR (shape outline) results file
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
VolVTemplateEditor.m
UpdateAAMFromDisk.m
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% aam = UpdateAAMFromDisk(aam); This function updates the AAM data structure that is passed between GUI's and reloads the relavent information that is written to disk. Dr. A. I. Hanna 2005
UpdateModel.m
UpdateModelSaveNewSet.m
%%%%%%%%%%%%%%%%%%%% Ensure that a new set is created %%%%%%%%%%%%%%%%%%%%%
UpdatePointModels.m
%%%%%%%%%%%%%%%%%%% Update Point Models Description: This tool asks the user for a revised template file and an old tempalte file, if the template files are similar, then the point models associated with the old template file are updated. Dr. A. I. Hanna (2005)
UpdateProjectTypes.m
Data=UpdateProjectTypes(Data) Description: Use dimensionality of pts (point model data) in the template to set the GUI 3D checkbox and project*.type file Author: J. Andrew Bangham Date: 2012
ViewGrowthTool.m
ViewGrowthTool(arg,option)
view a bud mesh model
arg, if 's' then force a stereo display
otherwise it should automatically produce a
stereo display if it detects two monitors
ViewGrowthTool
J. Andrew Bangham, 2008
calculatePointModelSetVariance.m
function [variance, meanshape] = calculatePointModelSetVariance(X) Takes a NxM matrix with N dimensions and M observations Dr. A. I. Hanna (2007)
centerPointModels.m
function X = centerPointModels(X, mu) Takes an NxM matrix where each column is a particular shape and centers it around zero. You can specify a Nx1 vector as the mean or you can let the function calculate the sample mean. Dr. A. I. Hanna (2007)
count_lines.m
type, 0 (default) count lines in all m files (recursively down directory)
1 store list of filenames in toolbox_m_file_help.txt
2 store help files in toolbox_m_file_help.txt
3 store listings in toolbox_m_file_help.txt
cwd, root directory (from which recursion will start)
(default is pwd)
N, number of lines
NC, number of characters
find_segments_to_smooth.m
consider each primary point in turn and create a list of points to which it is linked up to and including the next primary point
general_smoothlandmarks.m
getProjectType.m
[type] = getProjectType(projectDir) Description: A function to determine the type of the project Author: Johann Strasser Date: 070312
normalise_variance.m
function ALLX = normalise_variance(ALLX, norm_opt) Takes a cell structure where each cell is a NxM matrix, where each column is an observation and each row is a variable, i.e. each column of the matrix corresponds to 1 particular shape norm_opt - if norm_opt is 0 (default) then the shapes are normalised to the mean variance amongst them, if opt = 1 then the shapes will be normalised to unit variance. Dr. A. I. Hanna (2007)
pdmwalk.m
PDMWALK GUI to 'walk' a PDM through each mode of variation PDMWALK(1,'MODEL_PDM') will read from a PDM the file 'MODEL_PDM', PDMWALK(1,pdm) will use the PDM struct (pdm.Xm, pdm.P and pdm.b), PDMWALK will prompt for a file. cd 'C:\Documents and Settings\ab\My Documents\Matlab2004\Nicolas\Images\Modigliani2\ModelData' See also buildpdm Iain Matthews, UEA, Norwich J. Andrew Bangham, UEA 2005
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\AAMToolbox\procrustes
applytrm.m
APPLYTRM transform X by parameters in P
XP = APPLYTRM(X,P) rotates, scales and translates X
by applying the transformation matrix P where,
P(1) = s * cos(theta)
P(2) = s * sin(theta)
P(3) = tx
P(4) = ty
Barry-John Theobald, b.theobald@uea.ac.uk
School of Information Systems, University of East Anglia,
Norwich, NR4 7TJ, UK
Version 1.0
calctrm.m
CALCTRM calculate the transform parameters to align two shapes P = CALCTRM(S1,S2,W) calculates the translation, scale and rotation to align shape S2 with S1. W is a set of weights giving the relative stability of each data point. See also PDMBUILD APPLYTRM Barry-John Theobald, b.theobald@uea.ac.uk School of Information Systems, University of East Anglia, Norwich, NR4 7TJ, UK Version 1.0
pmalign.m
pmalign, point model alignment tool [xaligned, ProcrustesAlignment] = pmalign(x, opts); This function takes in the raw point models and then aligns them according to the options in opts. These options are a 1x3 array containing zeros or ones. For example opts = [1 1 1] will align the shapes according the scale, rotation and translation, so the structure of opts is as follows, opts = [toggle_scale, toggle_rotation, toggle_translation]; If you want to align your shapes to make rotations and translations invariant but you want to capture scaling, then use opts = [0 1 1]; The function returns 2 parameters, xaligned which are the aligned shapes, and ProcrustesAlignment which is a 4x1 array of numbers, with the following format ProcrustesAlignment = [scale*cos(theta), scale*sin(theta), trans_x, trans_y]'; It is in this format for compliance with applytrm written by Dr. Barry J. Theobald at the University of East Anglia. If you wish to get back to the origianl points from the aligned points, you simply use the command x_orig = applytrm(x, proc_data); Dr. A. I. Hanna (2005);
pmalign_old.m
pmalign, point model alignment tool
[xaligned, ProcrustesAlignment] = pmalign(x, opts);
This function takes in the raw point models and then aligns them
according to the options in opts. These options are a 1x3 array
containing zeros or ones. For example opts = [1 1 1] will align the
shapes according the scale, rotation and translation, so the structure of
opts is as follows, opts = [toggle_scale, toggle_rotation,
toggle_translation];
If you want to align your shapes to make rotations and translations
invariant but you want to capture scaling, then use opts = [0 1 1];
The function returns 2 parameters, xaligned which are the aligned shapes,
and ProcrustesAlignment which is a 4x1 array of numbers, with the
following format
x, one column per pointmodel (stored, x1,y1,x2,y2 ...)
opts, flags controlling [scale, rotation, translation] 0 for off else 1
Mean, one column representing a pointmodel to which x is to be aligned
(by default pmalign computes the mean x and uses that instead)
xaligned, pointmodes from x that have been aligned together
ProcrustesAlignment = [scale*cos(theta), scale*sin(theta), trans_x,
trans_y]';
It is in this format for compliance with applytrm written by Dr. Barry J.
Theobald at the University of East Anglia.
Dr. A. I. Hanna (2005);
project2tangentspace.m
function [X] = pcalib_project2tangentspace(X, meanshape)
A function that maps the aligned shapes in X to the tangent space given
by meanshape.
Inputs:
X - a MxN matrix where M is the dimension of the shape, and N is the number of samples.
NOTE: X is of the form X = [x_1, y_1, x_2, y_2, ..., x_N, y_N]'.
meanshape - this is the meanshape in question that defines the
projection onto the tangent space. It is a column vector with the same
structure as the columns in X.
Outputs:
X - the same structure as the input X, but the shapes have now
been projected into the tangent space.
Dr. A. I. Hanna (2006).
rename_current_directory.m
scalePointModels.m
setProjectType.m
setProjectType(projectDir,type) Description: A function to determine the type of the project type, either 'project2D' or 'project3D' Author: J. Andrew Bangham Date: 2012
setScalePointModels.m
strip_out_trailing_blanks.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\ConversionTools
AAMElementConverter.m
function [] = AAMElementConverter(class_template_file, structure_template_file) A tool to convert the class template file to structures used by toolbox2 Dr. A. I. Hanna (14-07-2005)
Copy of Faces11_place_fixed_points.m
function set_faces11_borderpoints_hat_beard(t)
from AAMToolbox create a new model based on faces8.temp_dat
(This will automatically create
cd into the required project folder and run the function
set points 159 to 166 to the border of the cropped image
t, 0 or empty do not pause after each edit set is identified
verbose, default 0, otherwise report full details of assignments
mistakes are very easy to make
J.Andrew Bangham, 2005
Faces10_old_place_fixed_points_old.m
function set_faces10_borderpoints from AAMToolbox create a new model based on faces8.temp_dat (This will automatically create cd into the required project folder and run the function set points 159 to 166 to the border of the cropped image
Faces10_place_fixed_points.m
function set_faces11_borderpoints_hat_beard(t)
from AAMToolbox create a new model based on faces8.temp_dat
(This will automatically create
cd into the required project folder and run the function
set points 159 to 166 to the border of the cropped image
name, name of _pm file with no path and _pm suffix
t, 0 or empty do not pause after each edit set is identified
verbose, default 0, otherwise report full details of assignments
mistakes are very easy to make
J.Andrew Bangham, 2005
Faces11_place_fixed_points.m
function set_faces11_borderpoints_hat_beard(t)
from AAMToolbox create a new model based on faces8.temp_dat
(This will automatically create
cd into the required project folder and run the function
set points 159 to 166 to the border of the cropped image
name, name of _pm file with no path and _pm suffix
t, 0 or empty do not pause after each edit set is identified
verbose, default 0, otherwise report full details of assignments
mistakes are very easy to make
J.Andrew Bangham, 2005
Faces9_place_fixed_points.m
function set_faces8_borderpoints from AAMToolbox create a new model based on faces8.temp_dat (This will automatically create cd into the required project folder and run the function set points 159 to 166 to the border of the cropped image
UpdateAllTemplates.m
function [] = UpdateAllTemplates(root_dir) Dr. A. I. Hanna (14-07-2005)
Update_pm_to_Templates.m
function [] = UpdateAllTemplates(root_dir) Dr. A. I. Hanna (14-07-2005)
edge_based_triangulation.m
md2temp_dat.m
function [] = md2temp(structure_template_file, class_template_file) A tool to convert the class template file to structures used by toolbox2 Dr. A. I. Hanna (14-07-2005)
set_faces10_borderpoints.m
function set_faces10_borderpoints from AAMToolbox create a new model based on faces8.temp_dat (This will automatically create cd into the required project folder and run the function set points 159 to 166 to the border of the cropped image
set_faces11_borderpoints_hat_beard.m
function set_faces11_borderpoints_hat_beard from AAMToolbox create a new model based on faces8.temp_dat (This will automatically create cd into the required project folder and run the function set points 159 to 166 to the border of the cropped image
set_faces8_borderpoints.m
function set_faces8_borderpoints from AAMToolbox create a new model based on faces8.temp_dat (This will automatically create cd into the required project folder and run the function set points 159 to 166 to the border of the cropped image
set_faces9_borderpoints.m
function set_faces8_borderpoints from AAMToolbox create a new model based on faces8.temp_dat (This will automatically create cd into the required project folder and run the function set points 159 to 166 to the border of the cropped image
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\ModelBuilder3DTool
modelBuilder3DTool.m
modelBuilder3DTool M-file for modelBuilder3DTool.fig Description: Author: Johann Strasser Date: 070312
modelBuilder3DToolVolViewer.m
modelBuilder3DTool M-file for modelBuilder3DTool.fig Description: Author: Andrew Bangham Date: 2012
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\TemplateBuilder3DTool
OpenVolViewer.m
templateBuilder3DTool.m
templateBuilder3DTool M-file for templateBuilder3DTool.fig Description: Author: Johann Strasser Date: 070312
templateBuilder3DToolVolViewer.m
templateBuilder3DToolVolViewer M-file for templateBuilder3DTool.fig Description: Author: Andrew Bangham Date: 2012 get the data structure from the main work flow control window
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\Utilities
AAMToolboxLibraryCheck.m
function str = AAMToolboxLibraryCheck Dr. A. I. Hanna (2007)
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\Utilities\BuildAugmentedPointModelsDialog
BuildAugmentedPointModelsDialog.m
Dr. A. I. Hanna (2005) CMP, UEA, 2005.
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\Utilities\FiguresForPapers
figure_1_points_around_leaf.m
function figure_1_points_around_leaf Example: figure_1_points_around_leaf; Dr. A. I. Hanna (2007)
figure_2_pc_effects.m
modeldir = 'C:\Documents and Settings\aih\My Documents\PostDoc\Shape_models\ModelsPrjs\Plants\Sandra\PRJ_Arabid_Antirrh\StatisticalModels\LE50Template_04_05_06\Set_1\ImageList_3';
figure_compare_selected_pcs.m
function figure_compare_selected_pcs Example: figure_compare_selected_pcs; Dr. A. I. Hanna (2007)
figure_show_original_and_modelled.m
this function generates a figure where each of the original shapes are shown and next to that is the modelled shape using a number of PC's
generateMeanAugmentedShapes.m
function generateMeanAugmentedShapes A. I. Hanna + A. Green, 2007
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\Utilities\FindFilenames
findfiles.m
Finds all files with the specified extension in the current directory and
subdirectories (recursive). Returns a cell array with the fully specified
file names.
files = findfiles( ext )
searches in the current directory and subdirectories.
files = findfiles( ext, directory)
starts search in directory specified.
files = findfiles( ext, directory, searchSubdirectories )
If searchSubdirectories == 0, the function will not descend
subdirectories. The default is that searchSubdirectories ~= 0.
Note: if this function causes your recursion limit to be exceeded, then
it is most probably trying to follow a symbolic link to a directory that
has a symbolic link back to the directory it came from.
Examples:
bmpfiles = findfiles('bmp')
dllfiles = findfiles('dll','C:\WinNT')
mfiles = findfiles('m',matlabroot)
findfilesext.m
Finds all files with the specified extension in the current directory and
subdirectories (recursive). Returns a cell array with the fully specified
file names.
files = findfiles( ext )
searches in the current directory and subdirectories.
files = findfiles( ext, directory)
starts search in directory specified.
files = findfiles( ext, directory, searchSubdirectories )
If searchSubdirectories == 0, the function will not descend
subdirectories. The default is that searchSubdirectories ~= 0.
Note: if this function causes your recursion limit to be exceeded, then
it is most probably trying to follow a symbolic link to a directory that
has a symbolic link back to the directory it came from.
Examples:
bmpfiles = findfiles('bmp')
dllfiles = findfiles('dll','C:\WinNT')
mfiles = findfiles('m',matlabroot)
ImportSimpleShape.m
%%%%%%%%%%%%%%%%%% ImportSimpleShape %%%%%%%%%%%%%%%%%%%
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\Utilities\MSRFiles3D
MSR2point_model_template.m
ShowMSR.m
convertMSRfilesToPointModelFiles.m
converts the MSR files in a dir to pm files
point_model_template2MSR.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\Utilities\OrderPointModels
OrderPointModels.m
SelectOrderListDlg Ordered List selection dialog box.
[SELECTION,OK] = OrderPointModels('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] = OrderPointModels('ListString',str);
Dr. A. I. Hanna (2005) CMP, UEA, 2005.
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\Utilities\PixelSorting
demo_sort.m
This is the test script for the image_sort function. The pixels of an image are sorted. Author: Atakan Varol
image_sort.m
IMAGE_SORT Sorts the given data points (pixels of an image)
in the data_ordered array
Usage: [data_ordered]= image_sort(x,y)
Warning:
It is assumed that the nearest pixel is not farther
than sqrt(2^15)=180 pixels
Written and tested in Matlab R14SP1
Date: 01.01.2005
Author: Atakan Varol
email: atakanvarol@su.sabanciuniv.edu
homepage: http://students.sabanciuniv.edu/~atakanvarol/
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\Utilities\PointModelConversions
fitSplineSmoothPts.m
data - xyz matrix of size (N,3) where N is the number of points interpRes - the resolution of the fitted spline numOfPoints - the number of points to be equispaced along the fitted spline funtion: 1) fits a cubic spline through the points data. 2) fits a number of points equispaced along the fitted spline Paul Southam(2012)
generatePMConversions.m
conversion PM files names and locations outline shape
longitudinalCS.m
longitudinalCSCurve.m
longOrTransToggle = 0 if doing longitudanal cross-section or longOrTransToggle = 1 if doing transverse cross-section
midToEdgeDistanceGenerateBlankImgs.m
%user select point models
[fName,pName] = uigetfile('DialogTitle','Select Point Model Files','MultiSelect','on');
midToEdgeDistanceGenerateModels.m
midToEdgeDistanceModel.m
Function generates a 2D kpar kper model from a 3D pointset. oldPts - 3D pointset (from for example, a 3D AAMToolbox project or 3D growth model). connectedPts - is a csv file which contains correspondence for the vertex numbers for edge and midvein points. modelType - 'simple' or 'angles'. Simple model calculates Euclidean distance from midvein points to corresponding edge pts (as designated by the connectedPts csv file) and plots them at 90 degrees. The angles model does the same but instead of plotting pts at 90 degree, plots them at a best fit angle calculated from the original 3D model. newModel - the generated 2D model.
midVeinRibGenerateModels.m
takes the midvein loop points. Fits best fit plane and projects points onto that plane. Fits a spline to the A and B side. Smooths points along that spline.
midVeinRibModel.m
function newModelData = midVeinRibModel(oldPts,connectedPts)
%%Obsolete function
debugPlot = 0
%% reshape the data into a useful format
data = reshape(oldPts,3,size(oldPts,1)/3)';
if(debugPlot)
plot3(data(:,1),data(:,2),data(:,3),'rx');
for j = 1:size(data,1)
text(data(j,1),data(j,2),data(j,3),num2str(j))
end
axis equal
end
%% calculate the midvein distances
midVeinIdxs = connectedPts;
for i = 1:size(connectedPts,1)-1
midVeinDistances(i,:) = sqrt(sum(abs(data(midVeinIdxs(i),:) - data(midVeinIdxs(i+1),:)).^2));
end
for i = 1:size(midVeinIdxs,1)-1
if(i == 1)
firstPtFlag = 1;
else
firstPtFlag = 0;
end
%find the pts
a = data(midVeinIdxs(i),:);
c = data(midVeinIdxs(i+1),:);
if(~firstPtFlag)
d = data(midVeinIdxs(i-1),:);
else
d = data(midVeinIdxs(end));
end
%move vectors to origin
a = a-a;
c = c-a;
d = d-a;
abAngles(i) = 180 - (acos(dot(c,d)/(norm(c)*norm(d)))*180/pi);
%abAngles(i) = acos(dot(c,d)/(norm(c)*norm(d)))*180/pi;
end
figure;hold on
for i = 1:size(midVeinDistances,1)-1
if(i == 1)
newModelData(1,:) = [0 0];
elseif(i == 2)
newModelData(2,:) = newModelData(1,:) - [midVeinDistances(1) 0];
elseif(i == 3)
if(abAngles(i) < 90)
x1 = newModelData(i-1,1) - cos(pi -(abAngles(i) * (pi/180))) * midVeinDistances(i);
y1 = newModelData(i-1,2) - sin(pi -(abAngles(i) * (pi/180))) * midVeinDistances(i);
else
x1 = newModelData(i-1,2) - cos((pi/2) -(abAngles(i) * (pi/180))) * midVeinDistances(i);
y1 = newModelData(i-1,1) - sin((pi/2) -(abAngles(i) * (pi/180))) * midVeinDistances(i);
end
newModelData(i,:) = [x1 - newModelData(i-1,1),y1 - newModelData(i-1,2)];
else
if(abAngles(i) < 90)
x1 = newModelData(i-1,1) - cos(pi -(abAngles(i) * (pi/180))) * midVeinDistances(i);
y1 = newModelData(i-1,2) - sin(pi -(abAngles(i) * (pi/180))) * midVeinDistances(i);
else
x1 = newModelData(i-1,2) - cos((pi/2) -(abAngles(i) * (pi/180))) * midVeinDistances(i);
y1 = newModelData(i-1,1) - sin((pi/2) -(abAngles(i) * (pi/180))) * midVeinDistances(i);
end
newModelData(i,:) = [x1,y1];
end
plot(newModelData(i,1),newModelData(i,2),'ob')
end
figure; plot(newModelData(:,1),newModelData(:,2),'ob')
hold on
for j = 1:size(newModelData,1)
text(newModelData(j,1),newModelData(j,2),num2str(j))
end
end
midVeinRibPerpThicknessGenerateModels.m
user select point models
midVeinRibPerpThicknessModel.m
midVeinRibThicknessGenerateModel.m
%user select point models
[fName,pName] = uigetfile('DialogTitle','Select Point Model Files','MultiSelect','on');
%user select connectivity file for midVeinRib - this file should be the
%loop that runs around the midvein. File name likely to be:
% 1) midVeinLoopNoPet.csv use for no petiole or
% 2) midVeinRib.csv use to include petiole
[facetName,facetPathName] = uigetfile('DialogTitle','Select connectivity file for midVeinRib','*.csv');
midVeinRibThicknessModel.m
midVeinRibViaPlaneModel.m
plotAllPointModels.m
showPM.m
transverseCS.m
PreProcessImages.m
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\Utilities\ProcrustesParamsDlg
ProcrustesParamsDlg.m
Dr. A. I. Hanna (2005) CMP, UEA, 2005.
ResizeImagesInFolder.m
directoryname = uigetdir(pwd);
files = dir([directoryname, filesep, '*.JPG']);
files = {files.name};
s = input('What resize ratio : ', 's');
s = str2num(s);
w = waitbar(0, 'Resizing Files...');
for f = 1:length(files)
waitbar(f/length(files), w);
I = imread([directoryname, filesep,files{f}]);
I = imresize(I, s);
imagesc(I);
axis image;
BW = roipoly;
L = bwlabel(BW);
S = regionprops(L, 'BoundingBox');
R = S(1).BoundingBox;
I2 = imcrop(I,R);
imwrite(I2, [directoryname, filesep,files{f}]);
end
close(w);
return;
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\Utilities\ScrollTextBox
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\Utilities\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\Toolboxes\ShapeModelToolbox\Utilities\SimpleShapes
UIShapeCreator.m
makeCircle.m
First generate the image with the right dimensions and save it.
makeSquare.m
r = makeSquare( r ) r is a 4-element array [x y w h] such as is used to represent rectangles in GUIs. This procedure trims r to be square, and centres the new square within the old rectangle.
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\Utilities\T-Test
rank_transformation_ttest.m
function [p, t] = rank_transformation_ttest(X1, X2) rank transformation of the t-tes Dr. A. I. Hanna (2007)
student.m
STUDENT Student's t-distribution.
S = STUDENT(T,N) gives the significance level S for a
given value of statistic T and degrees of freedom N
for a two-sided definition:
/t
1 | x^2
A(t|n) = ------------------ |(1 + ---)^((1+n)/2) dx
sqrt(n)*B(1/2,n/2) | n
/-t
Formula from W. H. Press, et. al., "Numerical Recipes
in C", Cambridge: Cambridge, 1988, p. 180 - 181.
ttest.m
Null Hypothesis: Population 1 (pop1) and Population 2 (pop2) are NOT different Syntax: [p,t]=ttest(pop1,pop2) DBE 4/17/01
C:\Users\AB\DArT_Toolshed\Toolboxes\ShapeModelToolbox\Utilities\TriangulationValidation
accumulatePoints.m
%%% %%%%
find_badareaincrease_triangles.m
Dr. A. I. Hanna (2006)
find_badratio_triangles.m
function [flipped_tri_ind] = find_flipped_triangles(T, ipts, opts) Dr. A. I. Hanna (2006)
find_flipped_triangles.m
function [flipped_tri_ind] = find_flipped_triangles(T, ipts, opts) Dr. A. I. Hanna (2006)
interp_tri_pts.m
function pts = interp_tri_pts(pts) A function that takes a 3x2 matrix that defines a triangle and interpolates along the edges. Input Params: pts - a 3x2 matrix of points Output Params: pts - a 6x2 matrix of points Dr. A. I. Hanna (2006). Used to calculated warps that need at least 6 points for a particular triangle
removeOutsideFaces.m
function triOut = removeOutsideFaces(tri, points, polygonVertices)
tri, the original triangulation data structure, indexing into
points, the triangulated point cloud.
polygonVertices, the vetex list defining the polygon which may be
concave. The third argument is a subset of the second
argument
triOut, the new triangle list which corresponds to tri with all
the triangles lying outside the polygon specified by
polygonVertices removed
showTri.m
tri_2d_calc_signed_area.m
tri_fill_image.m
calcProjVariance.m
function [projVar, Xp] = calcProjVariance(X, A) Dr. A. I. Hanna (2006)
calculate_group_appearance_means.m
calculate_group_shape_means.m
checkDir.m
%%%%%%%%%%%%%%%%%% Check that the directory is valid, i.e. it has Original and Cropped %%%%%%%%%%%%%%%%%%%
construct_project_directories.m
% %%
count_lines.m
type, 0 (default) count lines in all m files (recursively down directory)
1 store list of filenames in toolbox_m_file_help.txt
2 store help files in toolbox_m_file_help.txt
3 store listings in toolbox_m_file_help.txt
cwd, root directory (from which recursion will start)
(default is pwd)
N, number of lines
NC, number of characters
create_mask_for_template.m
function create_mask_for_template Dr. A. I. Hanna (2007)
cut_string.m
%%%%%%%%%%%%%%%%%%%%
cut_string //splits directory names so you can see the beginning and
//the end
%%%%%%%%%%%%%%%%%%%%%
extract_shape_PC_data.m
function B = extract_shape_PC_data(modeldirectory) This is a simple script that takes ALL the point models related to the current template and stores the points, the aligned points, and the pc values to a matlab binary file as defined by the user. related: shapematrix2excell, exportModelData, AAMToolbox Dr. A. I. Hanna (2006).
finddirs.m
Finds all files with the specified extension in the current directory and
subdirectories (recursive). Returns a cell array with the fully specified
file names.
files = findfiles( ext )
searches in the current directory and subdirectories.
files = findfiles( ext, directory)
starts search in directory specified.
files = findfiles( ext, directory, searchSubdirectories )
If searchSubdirectories == 0, the function will not descend
subdirectories. The default is that searchSubdirectories ~= 0.
Note: if this function causes your recursion limit to be exceeded, then
it is most probably trying to follow a symbolic link to a directory that
has a symbolic link back to the directory it came from.
Examples:
bmpfiles = findfiles('bmp')
dllfiles = findfiles('dll','C:\WinNT')
mfiles = findfiles('m',matlabroot)
gaussian_1d.m
function [x, y] = gaussian_1d(mean, std, range, N) A simple script that takes the mean and standard deviation of a gaussian and returns the x and y points to plot. Dr. A. I. Hanna (2006)
gen_rectangular_data.m
generate_listing.m
getAAMStructure.m
AAMStructure=getAAMStructure(PathName) PathName, the name of a AAMToolbox project (i.e. starts with 'PRJ_' Andrew Bangham, 2009
getBuildSettings.m
getCurrentAAMProjectName.m
getGUILevelInfo.m
function level = getGUILevelInfo Dr. A. I. Hanna (2006).
getImageLists2.m
getPdm.m
function pdm = getPdm(modeldir) Returns the pdm for model in modeldir from disk Dr. A. I. Hanna
get_template_info.m
%%%%%%%%%%%%%%%%%% template info %%%%%%%%%%%%%%%%%%%
import_prj_details.m
function import_prj_details(details) A function that takes the combined_project_details cell array and then stores the mean-shape and mean-appearance in PointModels/... and Cropped/... Dr. A. I. Hanna (2006)
isAugmentedProject.m
function [segmentpoint, offsets] = isAugmentedProject Checks to see if the current shape model direcoty is an augmented project, if so then it will return the segmentation points for the shapes and the offsets if they have been defined. Dr. A. I. Hanna (2007)
lda.m
function [Xm, P, b, pcaDat] = lda(X, N)
Note that in order for LDA to perfrom we need to have at least t + c
samples so that the inter-variance matrix does not become singular. Here
t denotes the dimension of our original data, and c denotes the number of
classes. So if we have 3 groups of faces where each faces is given by 100
points we need at least 103 faces. This in practice is unfeasible so we
generally project down onto a lower dimensional space using PCA.
Inputs:
X - a cell array of groups, each element of the cell array is a matrix
where every row is an observation and every column is a variable
N - the number of dimensions to project down to (default = 2)
Outputs:
Xm - the mean of the projected data
P - the projection matrix
b - the variance covered along those axes
pcaDat - the full P and b info.
Example:
figure(1); cla; hold on;
A = randn(100,3);
B = randn(100,3);
B(:,1:2) = B(:,1:2)+3;
plot3(A(:,1), A(:,2), A(:,3), 'o');
plot3(B(:,1), B(:,2), B(:,3), 'ro');
X{1} = A; X{2} = B;
[Xm, P, b, pcaDat] = lda(X, 2);
a = (P*A')';
b = (P*B')';
figure(2); clf; hold on;
plot(a(:,1), a(:,2), 'o');
plot(b(:,1), b(:,2), 'ro');
Dr. A. I. Hanna (2006).
load_group_images.m
load_group_pointmodels.m
function [X] = load_group_pointmodels(templatename, pm_files, prj_name) Dr. A. I. Hanna (2006)
max_var_ratio.m
function [P, b] = max_var_ratio(modelDirec, P, b) Dr. A. I. Hanna (2006)
mean_group_image.m
multi_slider.m
MULTI_SLIDER_SOURCE mutiple slider source block
% ==== Based on =============================================== %
% function slideg(varargin) % %
% SLIDEG Slider Gain block helper function. %
% SLIDEG manages the dialog box for the Slider Gain block. %
% All block and Handle Graphics callbacks are funneled through %
% this SLIDEG. %
% %
% Copyright 1990-2004 The MathWorks, Inc. %
% $Revision: 1.45.4.3 $ %
% %
% =============================================================== %
MULTI_SLIDER_SOURCE generate the manual slider source block.
Syntax:
multi_slider_source1p7(noSlider)
multi_slider_source1p7(low,high)
multi_slider_source1p7(low,high,gain)
multi_slider_source1p7(low,high,SliderLabel)
multi_slider_source1p7(low,high,gain,SliderLabel)
Description:
multi_slider_source1p7(noSlider)
requires only noSlider(number of the Sliders,scalar),
it generate a source block with outputs = noSlider.
multi_slider_source1p7(low,high)
requires low and high values in form of row vector,
it generate a source block with outputs = length(low), the size of low
and high should be the same, and high > low should be fulfilled.
multi_slider_source1p7(low,high,gain)
requires low, high and gain values in form of row vector, it generate
a source block with outputs = length(low), the size of low, high, and
gain should be the same, and high > gain > low should be fulfilled.
multi_slider_source1p7(low,high,SliderLabel)
requires low, high values in form of row vector and SliderLabel in form of
string cell array, the size of them should be the same, and high > low
should be fulfilled.
multi_slider_source1p7(low,high,gain,SliderLabel)
requires low, high, gain values in form of row vector and SliderLabel in
form of string cell array, the size of them should be the same, and
high > gain > low should be fulfilled.
Examples:
multi_slider_source1p7(3)
generate a multi slider source block with 3 sliders.
low = zeros(1,5);
high = 10*ones(1,5);
multi_slider_source1p7(low,high);
generate a multi slider source block with 5 sliders, which lower and upper
limits are zeros(1,5) and 10*ones(1,5).
low = zeros(1,3);
high = 5*ones(1,3);
gain = 2.5*ones(1,3);
multi_slider_source1p7(low,high,gain)
generate a multi slider source block with 3 sliders, which lower and
upper limits are defined by low, high. The position of the slider buttons
will be at 2.5*ones(1,3);
low = zeros(1,2);
high = 10*ones(1,2);
SliderLabel = [{Speed} {Voltage}];
multi_slider_source1p7(low,high,SliderLabel)
generate a multi slider source block with 2 sliders, which lower and
upper limits are defined by low, high. The slider label will be shown in
the middel of each sliders.
low = zeros(1,4);
high = 10*ones(1,4);
gain = 5*ones(1,4);
SliderLabel = [{Speed1} {Speed2} {Voltage} {Time}];
multi_slider_source1p7(low,high,gain,SliderLabel)
generate a multi slider source block with 2 sliders, which lower and
upper limits are defined by low, high. The position of the slider buttons
determined by gain. The slider label will be shown in the middel of each
sliders.
New Features:
Default: when clicked, reset all the parameters with original
values when you generate the Multi-Slider-Source block.
Save As Default: when clicked, save current min, max, Label, gain and
positions of sliders as default values.
Sets: when clicked, prompt a dialog to load input sets.
The sets can be column vector or matrix in the
order of Sliders. When dimension excessed, it gives a
warning massage and cut the vectors or matrix
automatically to match the dimension of your Multi-
Slider-Source block. When the dimension is less than
number of silders, it will be applied from the first
silder.
SetEdit: This edit box can only work when 'Sets:' button has
been excuted. Give the number of column of the set you
desired to use as input, if the number you entered is
larger than the maximun column number of your Sets matrix,
a warning massage will be given, and the maximun
column number of your Sets matrix will be set inside
the box.
version 1.5 Developed in MATLAB R14p1
The new version has make a modify in the GUI, add a scrollbar to solve
the limitation of numbers of sliders. Technically speaking, the program
can generate sliders as many as user requires. The floating buttons of
Default, Help and Close make user easly setting default, asking help, or
closing interface. But this can also be changed to be fixed when
uncomment lines 918-920, 1242-1244 and comment lines 928-930,
1252-1254.
The new version also add a function that to load data as inputs. Press
button 'Sets' to load data and give the number of set you want to used
in the edit field beside the button. The sequence of the data should as
same as the silder you defined.
version 1.6 Developed in MATLAB R14p1
The version 1.6 add a new button to save current values as default.
version 1.7 Developed in MATLAB R14p1
The version modify some bugs and add 2 new buttons to increase/decrease
Loading sets 1 by 1.
LINCENCE:
The code is free and can be spread.
Please keep all the information of this help as complete as possible.
Po Hu
05.08.2005
multi_slider_source1p7.m
MULTI_SLIDER_SOURCE mutiple slider source block
% ==== Based on =============================================== %
% function slideg(varargin) % %
% SLIDEG Slider Gain block helper function. %
% SLIDEG manages the dialog box for the Slider Gain block. %
% All block and Handle Graphics callbacks are funneled through %
% this SLIDEG. %
% %
% Copyright 1990-2004 The MathWorks, Inc. %
% $Revision: 1.45.4.3 $ %
% %
% =============================================================== %
MULTI_SLIDER_SOURCE generate the manual slider source block.
Syntax:
multi_slider_source1p7(noSlider)
multi_slider_source1p7(low,high)
multi_slider_source1p7(low,high,gain)
multi_slider_source1p7(low,high,SliderLabel)
multi_slider_source1p7(low,high,gain,SliderLabel)
Description:
multi_slider_source1p7(noSlider)
requires only noSlider(number of the Sliders,scalar),
it generate a source block with outputs = noSlider.
multi_slider_source1p7(low,high)
requires low and high values in form of row vector,
it generate a source block with outputs = length(low), the size of low
and high should be the same, and high > low should be fulfilled.
multi_slider_source1p7(low,high,gain)
requires low, high and gain values in form of row vector, it generate
a source block with outputs = length(low), the size of low, high, and
gain should be the same, and high > gain > low should be fulfilled.
multi_slider_source1p7(low,high,SliderLabel)
requires low, high values in form of row vector and SliderLabel in form of
string cell array, the size of them should be the same, and high > low
should be fulfilled.
multi_slider_source1p7(low,high,gain,SliderLabel)
requires low, high, gain values in form of row vector and SliderLabel in
form of string cell array, the size of them should be the same, and
high > gain > low should be fulfilled.
Examples:
multi_slider_source1p7(3)
generate a multi slider source block with 3 sliders.
low = zeros(1,5);
high = 10*ones(1,5);
multi_slider_source1p7(low,high);
generate a multi slider source block with 5 sliders, which lower and upper
limits are zeros(1,5) and 10*ones(1,5).
low = zeros(1,3);
high = 5*ones(1,3);
gain = 2.5*ones(1,3);
multi_slider_source1p7(low,high,gain)
generate a multi slider source block with 3 sliders, which lower and
upper limits are defined by low, high. The position of the slider buttons
will be at 2.5*ones(1,3);
low = zeros(1,2);
high = 10*ones(1,2);
SliderLabel = [{Speed} {Voltage}];
multi_slider_source1p7(low,high,SliderLabel)
generate a multi slider source block with 2 sliders, which lower and
upper limits are defined by low, high. The slider label will be shown in
the middel of each sliders.
low = zeros(1,4);
high = 10*ones(1,4);
gain = 5*ones(1,4);
SliderLabel = [{Speed1} {Speed2} {Voltage} {Time}];
multi_slider_source1p7(low,high,gain,SliderLabel)
generate a multi slider source block with 2 sliders, which lower and
upper limits are defined by low, high. The position of the slider buttons
determined by gain. The slider label will be shown in the middel of each
sliders.
New Features:
Default: when clicked, reset all the parameters with original
values when you generate the Multi-Slider-Source block.
Save As Default: when clicked, save current min, max, Label, gain and
positions of sliders as default values.
Sets: when clicked, prompt a dialog to load input sets.
The sets can be column vector or matrix in the
order of Sliders. When dimension excessed, it gives a
warning massage and cut the vectors or matrix
automatically to match the dimension of your Multi-
Slider-Source block. When the dimension is less than
number of silders, it will be applied from the first
silder.
SetEdit: This edit box can only work when 'Sets:' button has
been excuted. Give the number of column of the set you
desired to use as input, if the number you entered is
larger than the maximun column number of your Sets matrix,
a warning massage will be given, and the maximun
column number of your Sets matrix will be set inside
the box.
version 1.5 Developed in MATLAB R14p1
The new version has make a modify in the GUI, add a scrollbar to solve
the limitation of numbers of sliders. Technically speaking, the program
can generate sliders as many as user requires. The floating buttons of
Default, Help and Close make user easly setting default, asking help, or
closing interface. But this can also be changed to be fixed when
uncomment lines 918-920, 1242-1244 and comment lines 928-930,
1252-1254.
The new version also add a function that to load data as inputs. Press
button 'Sets' to load data and give the number of set you want to used
in the edit field beside the button. The sequence of the data should as
same as the silder you defined.
version 1.6 Developed in MATLAB R14p1
The version 1.6 add a new button to save current values as default.
version 1.7 Developed in MATLAB R14p1
The version modify some bugs and add 2 new buttons to increase/decrease
Loading sets 1 by 1.
LINCENCE:
The code is free and can be spread.
Please keep all the information of this help as complete as possible.
Po Hu
05.08.2005
pan.m
PAN Interactively pan the view of a plot PAN ON turns on mouse-based panning. PAN XON turns on x-only panning PAN YON turns on y-only panning PAN OFF turns it off. PAN by itself toggles the state. PAN(FIG,...) works on specified figure handle. Use LINKAXES to link panning across multiple axes. See also ZOOM, LINKAXES.
principal_component_analysis.m
function [Xm, P, b, pcaDat] = principle_component_analysis(X) A function that performs PCA on a matrix of data, where each column is an experiment, and each row corresponds to points in that experiment. re-arranged Dr. A. I. Hanna (2006).
principle_component_analysis.m
function [Xm, P, b, pcaDat] = principle_component_analysis(X) A function that performs PCA on a matrix of data, where each column is an experiment, and each row corresponds to points in that experiment. re-arranged Dr. A. I. Hanna (2006).
principle_component_analysis_old.m
function [Xm, P, b, pcaDat] = principle_component_analysis(X) A function that performs PCA on a matrix of data, where each column is an experiment, and each row corresponds to points in that experiment. re-arranged Dr. A. I. Hanna (2005).
procrustes.m
PROCRUSTES Perform Procrustes analysis on landmark data
[procdata,theta]=procrustes(data,templ)
[procdata,theta,templ]=procrustes(data)
The second version estimates a template.
data(i).marks = 2D landmarks, 2-by-p matrices
procdata(i).marks = landmarks aligned to a template, 2-by-p matrices
theta = Global transformation parameters,
theta(i).transl = translation
theta(i).phi = rotation
theta(i).scale = scale
produce_figure.m
rotmat.m
ROTMAT Compute a 2D rotation matrix R=rotmat(phi)
sammon.m
SAMMON - apply Sammon's nonlinear mapping
Y = SAMMON(X) applies Sammon's nonlinear mapping procedure on
multivariate data X, where each row represents a pattern and each column
represents a feature. On completion, Y contains the corresponding
co-ordinates of each point on the map. By default, a two-dimensional
map is created. Note if X contains any duplicated rows, SAMMON will
fail (ungracefully).
[Y,E] = SAMMON(X) also returns the value of the cost function in E (i.e.
the stress of the mapping).
An N-dimensional output map is generated by Y = SAMMON(X,N) .
A set of optimisation options can also be specified using a third
argument, Y = SAMMON(X,N,OPTS) , where OPTS is a structure with fields:
MaxIter - maximum number of iterations
TolFun - relative tolerance on objective function
MaxHalves - maximum number of step halvings
Input - {'raw','distance'} if set to 'distance', X is interpreted
as a matrix of pairwise distances.
Display - {'off', 'on', 'iter'}
The default options structure can be retrieved by calling SAMMON with
no parameters.
References:
[1] Sammon, John W. Jr., "A Nonlinear Mapping for Data Structure
Analysis", IEEE Transactions on Computers, vol. C-18, no. 5,
pp 401-409, May 1969.
saveSimpleShape.m
setGUILevelInfo.m
function setGUILevelInfo(level) Dr. A. I. Hanna (2006)
shapematrix2excell.m
function shapematrix2excell This is a simple script that asks the user for a Shape Matrix file and then converts that file to an excel file for input to gen-spring or some other classification tool. related: extract_shape_PC_data, exportModelData, AAMToolbox Dr. A. I. Hanna (2006)
show_group_model_estimates.m
Get the shape model
smooth_secondary_landmarks.m
splitPoints.m
function pts = splitPoints(pts, segpoint, offsets) This function takes a NxD point model, where N is the number of points and D is the dimension. Given an array of segment points and a set of offsets it returns the set of points translated and rotated by the values in offsets ready for drawing. See also: isAugmentedProject Dr. A. I. Hanna (2007)
trans_rot_points.m
function [pts] = trans_rot_points(pts, offset, theta) This function takes a NxD shape where N is the number of points in the shape and D is the dimension of the shape, together with a translation and an angle, the function returns the translated and rotated shape. See also: splitPoints, isAugmentedProject Dr. A. I. Hanna (2007)
tri_center.m
function [c] = tri_center(t) A function that returns the center of a triangle specified by t Input Params: t - a 3x2 matrix that defines a triangle. Output Params: c - the [x, y] position of the center of the triangle. Dr. A. I. Hanna (2006);
vectarrow.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 5 and is incompatible with
earlier MATLAB versions (ARROW for MATLAB 4.2c is available separately);
some problems with perspective plots still exist.
writelog.m
C:\Users\AB\DArT_Toolshed\Toolboxes\TICA
TICA.m
analyseMicrotubules.m
cellLabeler.m
circLineFit.m
edgeSegment.m
imageNormaliser.m
manualMask.m
mtLeafViewer.m
rotateticklabel.m
ROTATETICKLABEL rotates tick labels TH=ROTATETICKLABEL(H,ROT) is the calling form where H is a handle to the axis that contains the XTickLabels that are to be rotated. ROT is an optional parameter that specifies the angle of rotation. The default angle is 90. TH is a handle to the text objects created. For long strings such as those produced by datetick, you may have to adjust the position of the axes so the labels don't get cut off. Of course, GCA can be substituted for H if desired. TH=ROTATETICKLABEL([],[],'demo') shows a demo figure. Known deficiencies: if tick labels are raised to a power, the power will be lost after rotation. See also datetick.
C:\Users\AB\DArT_Toolshed\Toolboxes\TrackingToolbox
C:\Users\AB\DArT_Toolshed\Toolboxes\TrackingToolbox\Documentation
C:\Users\AB\DArT_Toolshed\Toolboxes\TrackingToolbox\GeneralMethods
mct_trackPoints.m
function [pts1, pts2] = mct_trackPoints(pts1, pts2) Applies the motion coherence method to aligning the two points pts1, and pts2. Dr. A. I. Hanna, CMP, 2008.
trklib_autoTrackPoints.m
function trklib_autoTrackPoints(varargin) Dr. A. I. Hanna, CMP, 2008.
trklib_calcGrowthParameters.m
function [m1, m2, tri, growthparams] = trklib_calcGrowthParameters(m1, m2, N, tri, dt) Dr. A. I. Hanna (2007)
trklib_genpcamodel.m
function trklib_genpcamodel Generates a PCA model based on tracked points
trklib_getGrowthRateLims.m
trklib_getTrackingDataDir.m
function trklib_getTrackingDataDir Dr. A. I. Hanna, CMP, 2008. Generates a PCA model based on tracked points
trklib_getindexedPointsXY.m
trklib_growthTensor2Params.m
TRKLIB_GROWTHTENSOR2PARAMS Extract the major and minor components of the growth tensor, together with the angle of rotation and the vorticity
trklib_markerAlignImages.m
function trklib_markerAlignImages(varargin)
imagesdir = 'Processed';
imfiles = dir([imagesdir, filesep, '*.tif']);
imfiles = {imfiles.name};
ptsdir = 'Data\TrackedPoints\';
ptsfiles = dir([ptsdir, filesep, '*.mat']);
ptsfiles = {ptsfiles.name};
markerAlignImages('images_dir', imagesdir, 'pts_Dir', ptsdir, 'image_files', imfiles, 'pts_files', ptsfiles);
Dr. A. I. Hanna, CMP, 2008.
trklib_placebycorrelation.m
function [m1,m2,cormat] = trklib_placebycorrelation(im1, p1, im2, w, dmax) w - window size over which the correlation is to be performed. dmax - maximum search radius Dr. A. I. Hanna, CMP, 2008.
trklib_plotArealGrowthRate.m
function trklib_plotArealGrowthRate(GData) Dr. A. I. Hanna, CMP, 2008.
trklib_plotDoublingTime.m
function trklib_plotDoublingTime(GData, dT) Dr. A. I. Hanna, CMP, 2008.
trklib_plotGrowthForStage.m
function trklib_plotGrowthForStage(varargin) Dr. A. I. Hanna, CMP, 2008.
trklib_plotInverseDoublingTime.m
function trklib_plotInverseDoublingTime(GData, dT) Dr. A. I. Hanna, CMP, 2008.
trklib_pts2growthparams.m
function growthparams = trklib_pts2growthparams(g1, g2, dt)
trklib_stagesToGrowthData.m
trklib_stagesToGrowthData('stage1fname', 'Data\TrackedPoints\02-T1-T2_adj_crop_001_pts.mat', 'stage2fname', 'Data\TrackedPoints\02-T1-T2_adj_crop_002_pts.mat');
trklib_trkpts2commonidxs.m
trklib_xyIndxPointsToStruct.m
C:\Users\AB\DArT_Toolshed\Toolboxes\TrackingToolbox\IOMethods
trklib_csv2track.m
CSV2TRACK(filename) Extract the data from a csv file create with the point_tracking python tool and convert it for the TrackingToolbox
trklib_loadImage.m
function trklib_loadImage(filename) Loads image for the tracking toolbox. Inputs: filename (string) Outputs: I (image) Dr. A. I. Hanna, CMP, 2008.
trklib_loadModel.m
function trklib_loadModel(varargin) Dr. A. I. Hanna, CMP, 2008.
trklib_loadPts.m
function trklib_loadPts(filename) Loads point files for the tracking toolbox. The file must be a structure with the following fields: pt, indx, edgecol, facecol. Inputs: filename (string) Outputs: pts (structure) Dr. A. I. Hanna, CMP, 2008.
trklib_loadPtsImage.m
function I = trklib_loadPtsImage(imagesdir, fname, ext) Inputs imagesdir - the directory where the images are stored fname - the filename of the trk points file e.g. image001_pts.mat ext - the extension of the images to be loaded Outputs I - the image corresponding to the point Dr. A. I. Hanna, CMP, 2008.
trklib_loadSegImage.m
function trklib_loadSegImage(filename) Loads segmented image for the tracking toolbox. Inputs: filename (string) Outputs: I (image) Dr. A. I. Hanna, CMP, 2008.
trklibio_loadTrackingData.m
function trk_data = trklibio_loadTrackingData(pathname, filename) Dr. A. I. Hanna (2007)
C:\Users\AB\DArT_Toolshed\Toolboxes\TrackingToolbox\TrackingToolbox
C:\Users\AB\DArT_Toolshed\Toolboxes\TrackingToolbox\TrackingToolbox\ImageProcessingTool
TRKImageProcessingTool.m
Hanna, 2005
C:\Users\AB\DArT_Toolshed\Toolboxes\TrackingToolbox\TrackingToolbox\RANSAC_Files
TRKLib_getimagestats.m
TRKLib_matchpoints.m
function [m1, m2, pts1, pts2] = TRKLib_matchpoints(S1, S2) Dr. A. I. Hanna (2007)
harris.m
HARRIS - Harris corner detector
Usage: cim = harris(im, sigma)
[cim, r, c] = harris(im, sigma, thresh, radius, disp)
[cim, r, c, rsubp, csubp] = harris(im, sigma, thresh, radius, disp)
Arguments:
im - image to be processed.
sigma - standard deviation of smoothing Gaussian. Typical
values to use might be 1-3.
thresh - threshold (optional). Try a value ~1000.
radius - radius of region considered in non-maximal
suppression (optional). Typical values to use might
be 1-3.
disp - optional flag (0 or 1) indicating whether you want
to display corners overlayed on the original
image. This can be useful for parameter tuning. This
defaults to 0
Returns:
cim - binary image marking corners.
r - row coordinates of corner points.
c - column coordinates of corner points.
rsubp - If five return values are requested sub-pixel
csubp - localization of feature points is attempted and
returned as an additional set of floating point
coords. Note that you may still want to use the integer
valued coords to specify centres of correlation windows
for feature matching.
If thresh and radius are omitted from the argument list only 'cim' is returned
as a raw corner strength image. You may then want to look at the values
within 'cim' to determine the appropriate threshold value to use. Note that
the Harris corner strength varies with the intensity gradient raised to the
4th power. Small changes in input image contrast result in huge changes in
the appropriate threshold.
hnormalise.m
HNORMALISE - Normalises array of homogeneous coordinates to a scale of 1
Usage: nx = hnormalise(x)
Argument:
x - an Nxnpts array of homogeneous coordinates.
Returns:
nx - an Nxnpts array of homogeneous coordinates rescaled so
that the scale values nx(N,:) are all 1.
Note that any homogeneous coordinates at infinity (having a scale value of
0) are left unchanged.
homography2d.m
HOMOGRAPHY2D - computes 2D homography
Usage: H = homography2d(x1, x2)
H = homography2d(x)
Arguments:
x1 - 3xN set of homogeneous points
x2 - 3xN set of homogeneous points such that x1<->x2
x - If a single argument is supplied it is assumed that it
is in the form x = [x1; x2]
Returns:
H - the 3x3 homography such that x2 = H*x1
This code follows the normalised direct linear transformation
algorithm given by Hartley and Zisserman "Multiple View Geometry in
Computer Vision" p92.
iscolinear.m
ISCOLINEAR - are 3 points colinear
Usage: r = iscolinear(p1, p2, p3, flag)
Arguments:
p1, p2, p3 - Points in 2D or 3D.
flag - An optional parameter set to 'h' or 'homog'
indicating that p1, p2, p3 are homogneeous
coordinates with arbitrary scale. If this is
omitted it is assumed that the points are
inhomogeneous, or that they are homogeneous with
equal scale.
Returns:
r = 1 if points are co-linear, 0 otherwise
matchbycorrelation.m
MATCHBYCORRELATION - match image feature points by correlation
Function generates putative matches between previously detected
feature points in two images by looking for points that are maximally
correlated with each other within windows surrounding each point.
Only points that correlate most strongly with each other in *both*
directions are returned.
This is a simple-minded N^2 comparison.
Usage: [m1,m2] = matchbycorrelation(im1, p1, im2, p2, w, dmax)
Arguments:
im1, im2 - Images containing points that we wish to match.
p1, p2 - Coordinates of feature pointed detected in im1 and
im2 respectively using a corner detector (say Harris
or phasecong2). p1 and p2 are [2xnpts] arrays though
p1 and p2 are not expected to have the same number
of points. The first row of p1 and p2 gives the row
coordinate of each feature point, the second row
gives the column of each point.
w - Window size (in pixels) over which the correlation
around each feature point is performed. This should
be an odd number.
dmax - (Optional) Maximum search radius for matching
points. Used to improve speed when there is little
disparity between images. Even setting it to a generous
value of 1/4 of the image size gives a useful
speedup. If this parameter is omitted it defaults to Inf.
Returns:
m1, m2 - Coordinates of points selected from p1 and p2
respectively such that (putatively) m1(:,i) matches
m2(:,i). m1 and m2 are [2xnpts] arrays defining the
points in each of the images in the form [row;col].
matchbymonogenicphase.m
MATCHBYMONOGENICPHASE - match image feature points using monogenic phase data
Function generates putative matches between previously detected
feature points in two images by looking for points that have minimal
differences in monogenic phase data within windows surrounding each point.
Only points that correlate most strongly with each other in *both*
directions are returned. This is a simple-minded N^2 comparison.
This matcher performs rather well relative to normalised greyscale
correlation. Typically there are more putative matches found and fewer
outliers. There is a greater computational cost in the pre-filtering stage
but potentially the matching stage is much faster as each pixel is effectively
encoded with only 3 bits. (Though this potential speed is not realized in this
implementation)
Usage: [m1,m2] = matchbymonogenicphase(im1, p1, im2, p2, w, dmax, ...
nscale, minWaveLength, mult, sigmaOnf)
Arguments:
im1, im2 - Images containing points that we wish to match.
p1, p2 - Coordinates of feature pointed detected in im1 and
im2 respectively using a corner detector (say Harris
or phasecong2). p1 and p2 are [2xnpts] arrays though
p1 and p2 are not expected to have the same number
of points. The first row of p1 and p2 gives the row
coordinate of each feature point, the second row
gives the column of each point.
w - Window size (in pixels) over which the phase bit codes
around each feature point are matched. This should
be an odd number.
dmax - Maximum search radius for matching points. Used to
improve speed when there is little disparity between
images. Even setting it to a generous value of 1/4 of
the image size gives a useful speedup.
nscale - Number of filter scales.
minWaveLength - Wavelength of smallest scale filter.
mult - Scaling factor between successive filters.
sigmaOnf - Ratio of the standard deviation of the Gaussian
describing the log Gabor filter's transfer function in
the frequency domain to the filter center frequency.
Returns:
m1, m2 - Coordinates of points selected from p1 and p2
respectively such that (putatively) m1(:,i) matches
m2(:,i). m1 and m2 are [2xnpts] arrays defining the
points in each of the images in the form [row;col].
I have had good success with the folowing parameters:
w = 11; Window size for correlation matching, 7 or greater
seems fine.
dmax = 50;
nscale = 1; Just one scale can give very good results. Adding
another scale doubles computation
minWaveLength = 10;
mult = 4; This is irrelevant if only one scale is used. If you do
use more than one scale try values in the range 2-4.
sigmaOnf = .2; This results in a *very* large bandwidth filter. A
large bandwidth seems to be very important in the
matching performance.
See Also: MATCHBYCORRELATION, MONOFILT
monofilt.m
MONOFILT - Apply monogenic filters to an image to obtain 2D analytic signal
Implementation of Felsberg's monogenic filters
Usage: [f, h1f, h2f, A, theta, psi] = ...
monofilt(im, nscale, minWaveLength, mult, sigmaOnf, orientWrap)
3 4 2 0.65 1/0
Arguments:
The convolutions are done via the FFT. Many of the parameters relate
to the specification of the filters in the frequency plane.
Variable Suggested Description
name value
----------------------------------------------------------
im Image to be convolved.
nscale = 3; Number of filter scales.
minWaveLength = 4; Wavelength of smallest scale filter.
mult = 2; Scaling factor between successive filters.
sigmaOnf = 0.65; Ratio of the standard deviation of the
Gaussian describing the log Gabor filter's
transfer function in the frequency domain
to the filter center frequency.
orientWrap 1/0 Optional flag 1/0 to turn on/off
'wrapping' of orientation data from a
range of -pi .. pi to the range 0 .. pi.
This affects the interpretation of the
phase angle - see note below. Defaults to 0.
Returns:
f - cell array of bandpass filter responses with respect to scale.
h1f - cell array of bandpass h1 filter responses wrt scale.
h2f - cell array of bandpass h2 filter responses.
A - cell array of monogenic energy responses.
theta - cell array of phase orientation responses.
psi - cell array of phase angle responses.
If orientWrap is 1 (on) theta will be returned in the range 0 .. pi and
psi (the phase angle) will be returned in the range -pi .. pi. If
orientWrap is 0 theta will be returned in the range -pi .. pi and psi will
be returned in the range -pi/2 .. pi/2. Try both options on an image of a
circle to see what this means!
Experimentation with sigmaOnf can be useful depending on your application.
I have found values as low as 0.2 (a filter with a *very* large bandwidth)
to be useful on some occasions.
See also: GABORCONVOLVE
nonmaxsuppts.m
NONMAXSUPPTS - Non-maximal suppression for features/corners
Non maxima suppression and thresholding for points generated by a feature
or corner detector.
Usage: [r,c] = nonmaxsuppts(cim, radius, thresh, im)
/
optional
[r,c, rsubp, csubp] = nonmaxsuppts(cim, radius, thresh, im)
Arguments:
cim - corner strength image.
radius - radius of region considered in non-maximal
suppression. Typical values to use might
be 1-3 pixels.
thresh - threshold.
im - optional image data. If this is supplied the
thresholded corners are overlayed on this
image. This can be useful for parameter tuning.
Returns:
r - row coordinates of corner points (integer valued).
c - column coordinates of corner points.
rsubp - If four return values are requested sub-pixel
csubp - localization of feature points is attempted and
returned as an additional set of floating point
coords. Note that you may still want to use the integer
valued coords to specify centres of correlation windows
for feature matching.
normalise2dpts.m
NORMALISE2DPTS - normalises 2D homogeneous points
Function translates and normalises a set of 2D homogeneous points
so that their centroid is at the origin and their mean distance from
the origin is sqrt(2). This process typically improves the
conditioning of any equations used to solve homographies, fundamental
matrices etc.
Usage: [newpts, T] = normalise2dpts(pts)
Argument:
pts - 3xN array of 2D homogeneous coordinates
Returns:
newpts - 3xN array of transformed 2D homogeneous coordinates. The
scaling parameter is normalised to 1 unless the point is at
infinity.
T - The 3x3 transformation matrix, newpts = T*pts
If there are some points at infinity the normalisation transform
is calculated using just the finite points. Being a scaling and
translating transform this will not affect the points at infinity.
randsample.m
RANDOMSAMPLE - selects n random items from an array
Usage: items = randomsample(a, n)
Arguments: a - Either an array of values from which the items are to
be selected, or an integer in which case the items
are values selected from the array [1:a]
n - The number of items to be selected.
This function can be used as a basic replacement for RANDSAMPLE for those
who do not have the statistics toolbox.
Also,
r = randomsample(n,n) will give a random permutation of the integers 1:n
See also: RANSAC
ransac.m
RANSAC - Robustly fits a model to data with the RANSAC algorithm
Usage:
[M, inliers] = ransac(x, fittingfn, distfn, degenfn s, t, feedback)
Arguments:
x - Data sets to which we are seeking to fit a model M
It is assumed that x is of size [d x Npts]
where d is the dimensionality of the data and Npts is
the number of data points.
fittingfn - Handle to a function that fits a model to s
data from x. It is assumed that the function is of the
form:
M = fittingfn(x)
Note it is possible that the fitting function can return
multiple models (for example up to 3 fundamental matrices
can be fitted to 7 matched points). In this case it is
assumed that the fitting function returns a cell array of
models.
If this function cannot fit a model it should return M as
an empty matrix.
distfn - Handle to a function that evaluates the
distances from the model to data x.
It is assumed that the function is of the form:
[inliers, M] = distfn(M, x, t)
This function must evaluate the distances between points
and the model returning the indices of elements in x that
are inliers, that is, the points that are within distance
't' of the model. Additionally, if M is a cell array of
possible models 'distfn' will return the model that has the
most inliers. If there is only one model this function
must still copy the model to the output. After this call M
will be a non-cell object representing only one model.
degenfn - Handle to a function that determines whether a
set of datapoints will produce a degenerate model.
This is used to discard random samples that do not
result in useful models.
It is assumed that degenfn is a boolean function of
the form:
r = degenfn(x)
It may be that you cannot devise a test for degeneracy in
which case you should write a dummy function that always
returns a value of 1 (true) and rely on 'fittingfn' to return
an empty model should the data set be degenerate.
s - The minimum number of samples from x required by
fittingfn to fit a model.
t - The distance threshold between a data point and the model
used to decide whether the point is an inlier or not.
feedback - An optional flag 0/1. If set to one the trial count and the
estimated total number of trials required is printed out at
each step. Defaults to 0.
Returns:
M - The model having the greatest number of inliers.
inliers - An array of indices of the elements of x that were
the inliers for the best model.
For an example of the use of this function see RANSACFITHOMOGRAPHY or
RANSACFITPLANE
ransacfithomography.m
RANSACFITHOMOGRAPHY - fits 2D homography using RANSAC
Usage: [H, inliers] = ransacfithomography(x1, x2, t)
Arguments:
x1 - 2xN or 3xN set of homogeneous points. If the data is
2xN it is assumed the homogeneous scale factor is 1.
x2 - 2xN or 3xN set of homogeneous points such that x1<->x2.
t - The distance threshold between data point and the model
used to decide whether a point is an inlier or not.
Note that point coordinates are normalised to that their
mean distance from the origin is sqrt(2). The value of
t should be set relative to this, say in the range
0.001 - 0.01
Note that it is assumed that the matching of x1 and x2 are putative and it
is expected that a percentage of matches will be wrong.
Returns:
H - The 3x3 homography such that x2 = H*x1.
inliers - An array of indices of the elements of x1, x2 that were
the inliers for the best model.
See Also: ransac, homography2d, homography1d
runnable.m
segment_images.m
function segmented = segment_images Dr. A. I. Hanna (2007)
C:\Users\AB\DArT_Toolshed\Toolboxes\TrackingToolbox\TrackingToolbox\SegmentationAlgorithms
TRKLib_segmentImages.m
function TRKLib_segmentImages(filenames, segmenteddirectory) Dr. A. I. Hanna (2007)
segment_sam_fluorescent_spots.m
C:\Users\AB\DArT_Toolshed\Toolboxes\TrackingToolbox\TrackingToolbox\TRKLib_CreateModelTool
TRKLib_CreateModelTool.m
function TRKLib_CreateModelTool(varargin) Dr. A. I. Hanna (2007) Dr. P. Barbier de Reuille (2008) %
C:\Users\AB\DArT_Toolshed\Toolboxes\TrackingToolbox\TrackingToolbox\TRKLib_PlotPicker
TRKLib_PlotPicker.m
function [schema] = TRKLib_PlotPicker TRKLib_PlotPicker Dr. A. I. Hanna, CMP, 2008.
C:\Users\AB\DArT_Toolshed\Toolboxes\TrackingToolbox\TrackingToolbox\TRKLib_TimeSeriesViewer
TRKLib_TimeSeriesViewer.m
function TRKLib_TimeSeriesViewer(varargin) Dr. A. I. Hanna (2007)
C:\Users\AB\DArT_Toolshed\Toolboxes\TrackingToolbox\TrackingToolbox\TRKLib_TrackerTool
TRKLib_TrackerTool.m
function TRKLib_TimeSeriesTool(varargin) Dr. A. I. Hanna (2007)
C:\Users\AB\DArT_Toolshed\Toolboxes\TrackingToolbox\TrackingToolbox\TRKLib_VectorFieldEditor
TRKLib_VectorFieldEditor.m
function TRKLib_VectorFieldEditor(varargin) Dr. A. I. Hanna (2007) % error(nargchk(0,inf,nargin));
C:\Users\AB\DArT_Toolshed\Toolboxes\TrackingToolbox\TrackingToolbox\TRK_AnalysisTool
TRK_AnalysisTool.m
function TRK_AnalysisTool Dr. A. I. Hanna (2007) %
TrackingToolbox.m
function TrackingToolbox(varargin) Example: TrackingToolbox; Dr. A. I. Hanna (2007) CMP, UEA, 2008.
C:\Users\AB\DArT_Toolshed\Toolboxes\TrackingToolbox\Utilities
checkTRKDir.m
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Check that the directory is valid, i.e. it has Original and Processed %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
getImageFiles.m
function files = getImageFiles(sourceDir) Dr. A. I. Hanna (2006)
get_project_segmentation_algorithm.m
C:\Users\AB\DArT_Toolshed\Toolboxes\VolumeAnalysisToolbox
C:\Users\AB\DArT_Toolshed\Toolboxes\VolumeAnalysisToolbox\3DGrowthAnalysisToolbox
C:\Users\AB\DArT_Toolshed\Toolboxes\VolumeAnalysisToolbox\3DGrowthAnalysisToolbox\src
VAToolbox.m
function [output] = VAToolbox()
actxlicense.m
C:\Users\AB\DArT_Toolshed\Toolboxes\VolumeAnalysisToolbox\3DGrowthAnalysisToolbox\src\common
changeFigureToolbarToSimple.m
Modified from AIH
deleteVolumeCentroidsRenderHandles.m
deleteVolumeEllipsoidRenderHandles.m
deleteVolumeIsosurfaceRenderHandles.m
deleteVolumeRegionIsosurfacesRenderHandles.m
find_dependencies.m
finds (nearly?) all functions external to filename on which filename depends
it tries to identify callback functions
And ignores all functions that are part of the Matlab build
filenames, string or cell array of filenames
including .fig files
listout, cell array of names
usage
find_dependencies({'ViewGrowthTool','ViewGrowthTool.fig'});
J. Andrew Bangham, 2008
fitEllipsoidsToLabeledVolume.m
function varargout = fitEllipsoidsToLabeledVolume(varargin) Description: Function to fit ellipsoids to a volume containing labelled regions Author: Johann Strasser Date: 071012
fitEllipsoidsToPointSet.m
function varargout = fitEllipsoidsToPointSet(varargin) Description: Function to fit ellipsoids to a 2D or 3D point set Author: Johann Strasser Date: 071012
getDateFromString.m
function varargout = getDateFromString(varargin)
Description:
Given a string, typically a directory- or filename containing a date in the
format of 'ts20060814_1724' return the same date in the format given by the standard
matlab date form number 31 ('yyyy-mm-dd HH:MM:SS'). Also see
function getDecendingDateFormat() which provides a standard interface to
the dateformat of use in the toolbox.
If the date string cannot be found we return the date with datenum(date)
== 0
Author: Johann Strasser
Date: 080331
getDecendingDateFormat.m
function varargout = getDecendingDateFormat(varargin)
Description:
Return the standard matlab date form number 31 ('yyyy-mm-dd HH:MM:SS')
Author: Johann Strasser
Date: 080331
getDefaultEllipsoidStructure.m
e = getDefaultEllipsoidStructure() Utility function to obtain an ellipsoid structure Author: Johann Strasser Date: 071022 (YYMMDD) Revision #1
getDefaultMetadataStructure.m
Description: Structure to hold metadata that can only deduced from the volume data itself. We store this information and write it to disk so subsequent tools have access to this information without having to load the volume data.
getDefaultRegionsStructure.m
getDefaultRenderOptions.m
getDefaultTrackingDataStructure.m
getDefaultTrackingUnitStructure.m
getDefaultVolumeCombinationRenderOptions.m
getDefaultVolumeStructure.m
getTransformedVertices.m
function varargout = getTransformedVertices(varargin) Description: Get the transformed volume space vertices of a specified feature representation of a volume
getVolumeColourModes.m
getVolumeCurrentSetDefinitions.m
Find out the current set definition
getVolumeRenderModel.m
jalphamap.m
ALPHAMAP - Set a figure's AlphaMap property
ALPHAMAP(MATRIX) - Set the current figure's AlphaMap property to MATRIX.
ALPHAMAP('default') - Set the AlphaMap to it's default value.
ALPHAMAP('rampup') - Create a linear alphamap with increasing opacity.
ALPHAMAP('rampdown') - Create a linear alphamap with decreasing opacity.
ALPHAMAP('vup') - Create an alphamap transparent in the center, and
linearly increasing to the beginning and end.
ALPHAMAP('vdown') - Create an alphamap opaque in the center, and
linearly decreasing to the beginning and end.
ALPHAMAP('increase') - Modify the alphamap making it more opaque.
ALPHAMAP('decrease') - Modify the alphamap making it more transparent.
ALPHAMAP('spin') - Rotate the current alphamap.
ALPHAMAP(PARAM, LENGTH) - For Parameters which create new maps, create
them with so they are LENGTH long.
ALPHAMAP(CHANGE, DELTA) - For parameters which change the alphamap, use
DELTA as a parameter.
ALPHAMAP(FIGURE,PARAM) - Set FIGURE's AlphaMap to some PARAMeter.
ALPHAMAP(FIGURE,PARAM,LENGTH)
ALPHAMAP(FIGURE,CHANGE)
ALPHAMAP(FIGURE,CHANGE,DELTA)
AMAP=ALPHAMAP - Fetch the current alphamap
AMAP=ALPHAMAP(FIGURE) - Fetch the current alphamap from FIGURE.
AMAP=ALPHAMAP(PARAM) - Return the alphamap based on PARAM
without setting the property.
See also ALPHA, ALIM, COLORMAP.
jcolormap.m
COLORMAP Color look-up table.
COLORMAP(MAP) sets the current figure's colormap to MAP.
COLORMAP('default') sets the current figure's colormap to
the root's default, whose setting is JET.
MAP = COLORMAP retrieves the current colormap. The values
are in the range from 0 to 1.
COLORMAP(AX,...) uses the figure corresponding to axes AX
instead of the current figure.
A color map matrix may have any number of rows, but it must have
exactly 3 columns. Each row is interpreted as a color, with the
first element specifying the intensity of red light, the second
green, and the third blue. Color intensity can be specified on the
interval 0.0 to 1.0.
For example, [0 0 0] is black, [1 1 1] is white,
[1 0 0] is pure red, [.5 .5 .5] is gray, and
[127/255 1 212/255] is aquamarine.
Graphics objects that use pseudocolor -- SURFACE and PATCH objects,
which are created by the functions MESH, SURF, and PCOLOR -- map
a color matrix, C, whose values are in the range [Cmin, Cmax],
to an array of indices, k, in the range [1, m].
The values of Cmin and Cmax are either min(min(C)) and max(max(C)),
or are specified by CAXIS. The mapping is linear, with Cmin
mapping to index 1 and Cmax mapping to index m. The indices are
then used with the colormap to determine the color associated
with each matrix element. See CAXIS for details.
Type HELP GRAPH3D to see a number of useful colormaps.
COLORMAP is an M-file that sets the Colormap property of a figure.
See also HSV, CAXIS, SPINMAP, BRIGHTEN, RGBPLOT, FIGURE, COLORMAPEDITOR.
loadDefaultViewpoint.m
loadEllipsoids.m
function varargout = loadEllipsoids(varargin) Description: Function to load ellipsoids from disk. Author: Johann Strasser Date: 071024
loadIsosurface.m
function varargout = loadIsosurface(varargin) Description: Function to load isosurface structure from disk. Author: Johann Strasser Date: 070926
loadMetadata.m
function varargout = loadMetadata(varargin) Description: loads loadMetadata structure fields from a specified directory. Refer to function getDefaultVolumeStructure() for the list of valid fields. Author: Johann Strasser Date: 080213
loadOriginalVolumeData.m
function varargout = loadOriginalVolumeData(varargin) Description: Loads original volume data into a volume structure Author: Johann Strasser Date: 071213
loadProcessedVolumeData.m
function varargout = loadProcessedVolumeData(varargin) Description: Loads processed volume data channel by channel into a volume structure and report back which channels where found Author: Johann Strasser Date: 071213
loadRegions.m
function varargout = loadRegions(varargin) Description: loads regions structure fields from a specified directory. Refer to function getDefaultRegionsStructure() for the list of valid fields. Author: Johann Strasser Date: 071214
loadRenderOptions.m
function varargout = loadRenderOptions(varargin) Description: loads renderOptions structure fields from a specified directory. Refer to function getDefaultRenderOptions() for the list of valid fields. Author: Johann Strasser Date: 080220
loadVolumeAreas.m
function volume = loadVolumeAreas(volumeseriesDirectory, volume) Description: Loads the areas part of the regions structures of a volume structure to disk. Author: Johann Strasser Date: 071213
loadVolumeCentroids.m
function volume = loadVolumeCentroids(volumeseriesDirectory, volume) Description: Loads the centroids part of the regions structures of a volume structure to disk. Author: Johann Strasser Date: 071213
loadVolumeDimensions.m
function volume = loadVolumeDimensions(volumeseriesDirectory, volume) Description: Load the dimensions part of the metadata structures of a volume structure from disk. Author: Johann Strasser Date: 080213
loadVolumeEllipsoids.m
function volume = loadVolumeEllipsoids(volumeseriesDirectory, volume) Description: Load the ellipsoids part of the regions structures of a volume structure to disk. Author: Johann Strasser Date: 071214
loadVolumeFalseColourData.m
function volume = loadVolumeFalseColourData(volumeseriesDirectory, volume) Description: Load the false colour parts of the renderOptions structures of a volume structure from disk. Author: Johann Strasser Date: 080220
loadVolumeIsosurfaces.m
function volume = loadVolumeIsosurfaces(volumeseriesDirectory, volume) Description: Load the isosurface part of the regions structures of a volume structure from disk. Author: Johann Strasser Date: 071214
loadVolumeNames.m
loadVolumeRegionIsosurfaces.m
function volume = loadVolumeRegionIsosurfaces(volumeseriesDirectory, volume) Description: Load the isosurfaces part of the regions structures of a volume structure from disk. Author: Johann Strasser Date: 080612
loadVolumeRegionSets.m
function volume = loadVolumeRegionSets(volumeseriesDirectory, volume) Description: Load the sets part of the regions structures of a volume structure from disk. Author: Johann Strasser Date: 080709
matlabTest.m
monitormatlab.m
MONITORMATLAB Displays runtime diagnostic information This task manager like tool displays real time memory state of MATLAB, HG, and Java using time based strip charts. The following information is displayed: * Memory allocated by MATLAB * Memory allocated by Java * Memory allocted by the O/S * Number of HG objects in memory * Number of MFiles in MATLAB memory * Size of m-file parsing stack To see real time MATLAB memory allocation, start MATLAB with the O/S environment flag "MATLAB_MEM_MGR" set to a "debug" as in: set MATLAB_MEM_MGR = debug. Example: monitormatlab bench
renderEllipsoids.m
function varargout = renderEllipsoids(varargin) Description: Function to render ellipsoids in given axes Author: Johann Strasser Date: 071023
renderRegionIsosurfaces.m
function varargout = renderRegionIsosurfaces(varargin) Description: Function to render render individual region isosurfaces in given axes Author: Johann Strasser Date: 080612
renderVolume.m
function [volumeRenderModel] = renderVolume(varargin)
Based on Vol3d Copyright Joe Conti, 2004, The Mathworks
Source: Matlab Central File Exchange
Adapted by Johann Strasser for rgb volume rendering.
Take the maximum intensity as the alpha value, i.e. for each pixel
alpha = max([r, g, b])
When AlphaDataMapping is set to direct we use max(slice, [], 3) and set
an appropriate alphamap for the figure
Do not set to scaled (default) as each slice's alpha data would then be
scaled to fit into the limits defined by the 'ALim' property of the axes.
This results in slices in a volume getting too opaque.
Note that the point of using alphamaps is to be able to change the alpha
mapping. Note that even we pass a uint8 array als AlphaData, it is
evident from the plot editor at runtime that matlab casts it to double.
CDataMapping is set to direct for similar reasons as setting
AlphaDataMapping to direct. When a single channel volume is used the data
in is used to index in the colourmap. If the default setting for
CDataMapping was used the intensitiy values of each slice would be scaled
separately to span the range of the colourmap. This leads to
non-intuitive display of intensity values as the same value may be scaled
differently in each slice. Note that it is assumed that the colourmap is
setup correctly (i.e.) it is set to the range of the intensity values.
Furthermore note that the alphamap is a property of the figure. A
colourmap on the other hand is bound to an axes!
For original vol3d description see below
H = VOL3D Volume render 3-D data.
VOL3D uses the orthogonal plane 2-D texture mapping technique for
volume rending 3-D data in OpenGL. Use the 'texture' option to fine
tune the texture mapping technique. This function is best used with
fast OpenGL hardware.
H = vol3d('CData',data) Create volume render object from input
3-D data. Use interp3 on data to increase volume
rendering resolution. Returns a struct
encapsulating the pseudo-volume rendering object.
vol3d(...'Parent',axH) Specify parent axes
vol3d(...,'texture','2D') Default. Only render texture planes parallel
to nearest orthogonal viewing plane. Requires
doing vol3d(h) to refresh if the view is
rotated (i.e. using cameratoolbar).
vol3d(...,'texture','3D') Render x,y,z texture planes simultaneously.
This avoids the need to refresh the view but
requires faster OpenGL hardware peformance.
vol3d(H) Refresh view. Updates rendering of texture planes
to reduce visual aliasing when using the 'texture'='2D'
option.
NOTES
Use vol3dtool for editing the colormap and alphamap.
Adjusting these maps will allow you to explore your 3-D volume
data at various intensity levels. See documentation on
alphamap and colormap for more information.
Use interp3 on input date to increase/decrease resolution of data
Examples:
% Visualizing fluid flow
v = flow(50);
h = vol3d('cdata',v,'texture','2D');
view(3);
% Update view since 'texture' = '2D'
vol3d(h);
alphamap('rampdown'), alphamap('decrease'), alphamap('decrease')
% Visualizing MRI data
load mri.mat
D = squeeze(D);
h = vol3d('cdata',D,'texture','2D');
view(3);
% Update view since 'texture' = '2D'
vol3d(h);
axis tight; daspect([1 1 .4])
alphamap('rampup');
alphamap(.06 .* alphamap);
See also vol3dtool, alphamap, colormap, opengl, isosurface
renderVolumeBackup.m
function [volumeRenderModel] = renderVolume(varargin)
Based on Vol3d Copyright Joe Conti, 2004, The Mathworks
Source: Matlab Central File Exchange
Adapted by Johann Strasser for rgb volume rendering.
Take the maximum intensity as the alpha value, i.e. for each pixel
alpha = max([r, g, b])
When AlphaDataMapping is set to direct we use max(slice, [], 3) and set
an appropriate alphamap for the figure
Do not set to scaled (default) as each slice's alpha data would then be
scaled to fit into the limits defined by the 'ALim' property of the axes.
This results in slices in a volume getting too opaque.
Note that the point of using alphamaps is to be able to change the alpha
mapping. Note that even we pass a uint8 array als AlphaData, it is
evident from the plot editor at runtime that matlab casts it to double.
CDataMapping is set to direct for similar reasons as setting
AlphaDataMapping to direct. When a single channel volume is used the data
in is used to index in the colourmap. If the default setting for
CDataMapping was used the intensitiy values of each slice would be scaled
separately to span the range of the colourmap. This leads to
non-intuitive display of intensity values as the same value may be scaled
differently in each slice. Note that it is assumed that the colourmap is
setup correctly (i.e.) it is set to the range of the intensity values.
Furthermore note that the alphamap is a property of the figure. A
colourmap on the other hand is bound to an axes!
For original vol3d description see below
H = VOL3D Volume render 3-D data.
VOL3D uses the orthogonal plane 2-D texture mapping technique for
volume rending 3-D data in OpenGL. Use the 'texture' option to fine
tune the texture mapping technique. This function is best used with
fast OpenGL hardware.
H = vol3d('CData',data) Create volume render object from input
3-D data. Use interp3 on data to increase volume
rendering resolution. Returns a struct
encapsulating the pseudo-volume rendering object.
vol3d(...'Parent',axH) Specify parent axes
vol3d(...,'texture','2D') Default. Only render texture planes parallel
to nearest orthogonal viewing plane. Requires
doing vol3d(h) to refresh if the view is
rotated (i.e. using cameratoolbar).
vol3d(...,'texture','3D') Render x,y,z texture planes simultaneously.
This avoids the need to refresh the view but
requires faster OpenGL hardware peformance.
vol3d(H) Refresh view. Updates rendering of texture planes
to reduce visual aliasing when using the 'texture'='2D'
option.
NOTES
Use vol3dtool for editing the colormap and alphamap.
Adjusting these maps will allow you to explore your 3-D volume
data at various intensity levels. See documentation on
alphamap and colormap for more information.
Use interp3 on input date to increase/decrease resolution of data
Examples:
% Visualizing fluid flow
v = flow(50);
h = vol3d('cdata',v,'texture','2D');
view(3);
% Update view since 'texture' = '2D'
vol3d(h);
alphamap('rampdown'), alphamap('decrease'), alphamap('decrease')
% Visualizing MRI data
load mri.mat
D = squeeze(D);
h = vol3d('cdata',D,'texture','2D');
view(3);
% Update view since 'texture' = '2D'
vol3d(h);
axis tight; daspect([1 1 .4])
alphamap('rampup');
alphamap(.06 .* alphamap);
See also vol3dtool, alphamap, colormap, opengl, isosurface
renderVolumeCentroids.m
function varargout = renderVolumeCentroids(varargin) Description: Render region centroids of a given volume structure
renderVolumeCombinationVectorFields.m
function varargout = renderVolumeCombinationVectorFields(varargin) Description: Render isosurfaces of a given volume structure
renderVolumeEllipsoids.m
function varargout = renderVolumeIsosurfaces(varargin) Description: Render ellipsoids of a given volume structure
renderVolumeIsosurfaces.m
function varargout = renderVolumeIsosurfaces(varargin) Description: Render isosurfaces of a given volume structure
renderVolumeRegionIsosurfaces.m
function varargout = renderVolumeRegionIsosurfaces(varargin) Description: Render individual region isosurfaces of a given volume structure
saveDefaultViewpoint.m
saveMetadata.m
function varargout = saveMetadata(varargin) Description: Saves metadata structure fields to a specified directory. Refer to function getDefaultVolumeStructure() for the list of valid fields. Author: Johann Strasser Date: 080213
saveProcessedVolumeData.m
saveRegions.m
function varargout = saveRegions(varargin) Description: Saves regions structure fields to a specified directory. Refer to function getDefaultRegionsStructure() for the list of valid fields. Author: Johann Strasser Date: 071212
saveRenderOptions.m
function varargout = saveRenderOptions(varargin) Description: Saves a render options structure fields to a specified directory. Refer to function getDefaultRenderOptions() for the list of valid fields. Author: Johann Strasser Date: 080220
saveVolume.m
function varargout = saveVolume(varargin) Description: Saves a single channel or RGB volume to a specified directory
saveVolumeAreas.m
function volume = saveVolumeAreas(volumeseriesDirectory, volume) Description: Saves the areas part of the regions structures of a volume structure to disk. Author: Johann Strasser Date: 071213
saveVolumeCentroids.m
function volume = saveVolumeCentroids(volumeseriesDirectory, volume) Description: Saves the centroids part of the regions structures of a volume structure to disk. Author: Johann Strasser Date: 071213
saveVolumeDimensions.m
function volume = saveVolumeDimensions(volumeseriesDirectory, volume) Description: Saves volume metadata to the metadata file on disk. Author: Johann Strasser Date: 080213
saveVolumeEllipsoids.m
function volume = saveVolumeEllipsoids(volumeseriesDirectory, volume) Description: Saves the ellipsoids part of the regions structures of a volume structure to disk. Author: Johann Strasser Date: 071213
saveVolumeFalseColourData.m
function volume = saveVolumeFalseColourData(volumeseriesDirectory, volume) Description: Saves volume false colour data to the render options file on disk. Author: Johann Strasser Date: 080220
saveVolumeIsosurfaces.m
function volume = saveVolumeIsosurfaces(volumeseriesDirectory, volume) Description: Saves the isosurface part of the regions structures of a volume structure to disk. Author: Johann Strasser Date: 071213
saveVolumeRegionIsosurfaces.m
function volume = saveVolumeRegionIsosurfaces(volumeseriesDirectory, volume) Description: Saves the isosurfaces part of the regions structures of a volume structure to disk. Author: Johann Strasser Date: 080612
saveVolumeRegionSets.m
function volume = saveVolumeRegionSets(volumeseriesDirectory, volume) Description: Saves the set part of the regions structures of a volume structure to disk. Author: Johann Strasser Date: 080709
storageEstimate.m
Note that we use base ten not base two due to most people (even computer hardware vendors!) having adopted the more intuitive base ten description of storage.
updateLimits.m
viewVolumeHideParentFigErrorSafe.m
getDefaultSimulationVolumeCombinationStructure.m
C:\Users\AB\DArT_Toolshed\Toolboxes\VolumeAnalysisToolbox\3DGrowthAnalysisToolbox\src\guiToolTemplate
guiToolTemplate.m
guiToolTemplate M-file for guiToolTemplate.fig Description: Remark: The ouput argument is only used in debugging. All data are written to disk. Similarly no input except the project directory is required as all data are read from disk. Author: Johann Strasser Date: 070717
pathdef_080619.m
PATHDEF Search path defaults. PATHDEF returns a string that can be used as input to MATLABPATH in order to set the path.
C:\Users\AB\DArT_Toolshed\Toolboxes\VolumeAnalysisToolbox\3DGrowthAnalysisToolbox\src\projectTool
projectTool.m
projectTool M-file for projectTool.fig Description: Remark: The ouput argument is only used in debugging. All data are written to disk. Similarly no input except the project directory is required as all data are read from disk. Author: Johann Strasser Date: 070717
scratch.m
C:\Users\AB\DArT_Toolshed\Toolboxes\VolumeAnalysisToolbox\3DGrowthAnalysisToolbox\src\trackingTool
calculateSurfaceGrowthOfVolumesWithIndices.m
deleteVolumeCombinationDisplacementVectorsRenderHandles.m
deleteVolumeCombinationVectorFieldsRenderHandles.m
getDefaultMCTData.m
getDefaultMCTParameters.m
getDefaultMCTSimulationData.m
MCTSimulationData.coefficients = [];
getDefaultSimulationDataStructure.m
getDefaultSimulationUnitStructure.m
getDefaultVolumeCombinationStructure.m
getTrackingUnitVectorFieldAndGrid.m
getVolumeCombinationCentroidGrowthData.m
getVolumeCombinationSurfaceVectors.m
renderVolumeCombinationDisplacementVectors.m
function varargout = renderVolumeCombinationDisplacementVectors(varargin) Description: Render the displacement vectors of a of features being tracked
surfaceDisplacementVectorFieldGradientMagnitude.m
trackCentroidsOfVolumesWithIndices.m
trackingTool.m
trackingTool M-file for trackingTool.fig Description: Remark: The ouput argument is only used in debugging. All data are written to disk. Similarly no input except the project directory is required as all data are read from disk. Author: Johann Strasser Date: 071101
trackingTool2Popupmenus.m
trackingTool M-file for trackingTool.fig Description: Remark: The ouput argument is only used in debugging. All data are written to disk. Similarly no input except the project directory is required as all data are read from disk. Author: Johann Strasser Date: 071101
trackingToolNoSidebarButtons.m
trackingTool M-file for trackingTool.fig Description: Remark: The ouput argument is only used in debugging. All data are written to disk. Similarly no input except the project directory is required as all data are read from disk. Author: Johann Strasser Date: 071101
C:\Users\AB\DArT_Toolshed\Toolboxes\VolumeAnalysisToolbox\3DGrowthAnalysisToolbox\src\volumeProcessingTool
C:\Users\AB\DArT_Toolshed\Toolboxes\VolumeAnalysisToolbox\3DGrowthAnalysisToolbox\src\volumeProcessingTool\activeContoursAIH
active_contour_chan_vese2d.m
function varargout = active_contour_chan_vese2d(varargin)
A method that implements the Chan-Vese model applied to image
segmentation. This model is a special case of the Mumford-Shah model and
it tries to separate the image into regions based on intensities.
Default parameters:
'image' - the input image (default = 'pout.tif')
'phi' - the initial distance function (default = circular disk)
'lambda1' - weight of energy inside the contour (default = 0.5)
'lambda2' - weight of energy outside the contour (default = 0.5)
'mu' - weighting for the length of the contour (default = 1)
'nu' - weighting of area of the contour (default = 1)
'deltaT' - step size for the update of phi (default = 0.5, note: 0.01<=deltaT<=0.9)
'verbose' - shows the evolution of the curve phi (default = 0)
'max_iter' - the maximum number of iterations to perform (default = 10)
'normforceflag' - normalizes the force term at every iteration (default = 1)
Example:
active_contour_chan_vese2d('verbose', 1);
Paper: "Minimizing Functionals: A Level Set Approach", A. I. Hanna, School of Computing Sciences, University of East Anglia, 2007.
URL: http://www2.cmp.uea.ac.uk/~aih/papers/MinimizingFunctionalsUsingLevelSets/MinimizingFunctionals-ALevelSetApproach_hanna.pdf
Dr. A. I. Hanna (2007)
active_contour_chan_vese2d_experimental.m
function varargout = active_contour_chan_vese2d(varargin)
A method that implements the Chan-Vese model applied to image
segmentation. This model is a special case of the Mumford-Shah model and
it tries to separate the image into regions based on intensities.
Default parameters:
'image' - the input image (default = 'pout.tif')
'phi' - the initial distance function (default = circular disk)
'lambda1' - weight of energy inside the contour (default = 0.5)
'lambda2' - weight of energy outside the contour (default = 0.5)
'mu' - weighting for the length of the contour (default = 1)
'nu' - weighting of area of the contour (default = 1)
'deltaT' - step size for the update of phi (default = 0.5, note: 0.01<=deltaT<=0.9)
'verbose' - shows the evolution of the curve phi (default = 0)
'max_iter' - the maximum number of iterations to perform (default = 10)
'normforceflag' - normalizes the force term at every iteration (default = 1)
Example:
active_contour_chan_vese2d('verbose', 1);
Paper: "Minimizing Functionals: A Level Set Approach", A. I. Hanna, School of Computing Sciences, University of East Anglia, 2007.
URL: http://www2.cmp.uea.ac.uk/~aih/papers/MinimizingFunctionalsUsingLevelSets/MinimizingFunctionals-ALevelSetApproach_hanna.pdf
Dr. A. I. Hanna (2007)
active_contour_chan_vese3d.m
function varargout = active_contour_chan_vese3d(varargin)
A method that implements the Chan-Vese model applied to volume
segmentation. This model is a special case of the Mumford-Shah model and
it tries to separate the volume into sub-volumes based on intensities.
Default parameters:
'volume' - the input volume
'phi' - the initial distance function (default = circular disk)
'lambda1' - weight of energy inside the contour (default = 0.5)
'lambda2' - weight of energy outside the contour (default = 0.5)
'mu' - weighting for the length of the contour (default = 1)
'nu' - weighting of area of the contour (default = 1)
'deltaT' - step size for the update of phi (default = 0.5, note: 0.01<=deltaT<=0.9)
'verbose' - shows the evolution of the curve phi (default = 0)
'max_iter' - the maximum number of iterations to perform (default = 10)
'normforceflag' - normalizes the force term at every iteration (default = 1)
Example:
active_contour_chan_vese3d('verbose', 1);
Paper: "Minimizing Functionals: A Level Set Approach", A. I. Hanna, School of Computing Sciences, University of East Anglia, 2007.
URL: http://www2.cmp.uea.ac.uk/~aih/papers/MinimizingFunctionalsUsingLevelSets/MinimizingFunctionals-ALevelSetApproach_hanna.pdf
Dr. A. I. Hanna (2007)
active_contour_clearVar_chan_vese3d.m
function varargout = active_contour_chan_vese3d(varargin)
A method that implements the Chan-Vese model applied to volume
segmentation. This model is a special case of the Mumford-Shah model and
it tries to separate the volume into sub-volumes based on intensities.
Default parameters:
'volume' - the input volume
'phi' - the initial distance function (default = circular disk)
'lambda1' - weight of energy inside the contour (default = 0.5)
'lambda2' - weight of energy outside the contour (default = 0.5)
'mu' - weighting for the length of the contour (default = 1)
'nu' - weighting of area of the contour (default = 1)
'deltaT' - step size for the update of phi (default = 0.5, note: 0.01<=deltaT<=0.9)
'verbose' - shows the evolution of the curve phi (default = 0)
'max_iter' - the maximum number of iterations to perform (default = 10)
'normforceflag' - normalizes the force term at every iteration (default = 1)
Example:
active_contour_chan_vese3d('verbose', 1);
Paper: "Minimizing Functionals: A Level Set Approach", A. I. Hanna, School of Computing Sciences, University of East Anglia, 2007.
URL: http://www2.cmp.uea.ac.uk/~aih/papers/MinimizingFunctionalsUsingLevelSets/MinimizingFunctionals-ALevelSetApproach_hanna.pdf
Dr. A. I. Hanna (2007)
active_contour_clearVar_chan_vese3d_071115_Backup.m
function varargout = active_contour_chan_vese3d(varargin)
A method that implements the Chan-Vese model applied to volume
segmentation. This model is a special case of the Mumford-Shah model and
it tries to separate the volume into sub-volumes based on intensities.
Default parameters:
'volume' - the input volume
'phi' - the initial distance function (default = circular disk)
'lambda1' - weight of energy inside the contour (default = 0.5)
'lambda2' - weight of energy outside the contour (default = 0.5)
'mu' - weighting for the length of the contour (default = 1)
'nu' - weighting of area of the contour (default = 1)
'deltaT' - step size for the update of phi (default = 0.5, note: 0.01<=deltaT<=0.9)
'verbose' - shows the evolution of the curve phi (default = 0)
'max_iter' - the maximum number of iterations to perform (default = 10)
'normforceflag' - normalizes the force term at every iteration (default = 1)
Example:
active_contour_chan_vese3d('verbose', 1);
Paper: "Minimizing Functionals: A Level Set Approach", A. I. Hanna, School of Computing Sciences, University of East Anglia, 2007.
URL: http://www2.cmp.uea.ac.uk/~aih/papers/MinimizingFunctionalsUsingLevelSets/MinimizingFunctionals-ALevelSetApproach_hanna.pdf
Dr. A. I. Hanna (2007)
active_contour_test_chan_vese3d.m
function varargout = active_contour_chan_vese3d(varargin)
A method that implements the Chan-Vese model applied to volume
segmentation. This model is a special case of the Mumford-Shah model and
it tries to separate the volume into sub-volumes based on intensities.
Default parameters:
'volume' - the input volume
'phi' - the initial distance function (default = circular disk)
'lambda1' - weight of energy inside the contour (default = 0.5)
'lambda2' - weight of energy outside the contour (default = 0.5)
'mu' - weighting for the length of the contour (default = 1)
'nu' - weighting of area of the contour (default = 1)
'deltaT' - step size for the update of phi (default = 0.5, note: 0.01<=deltaT<=0.9)
'verbose' - shows the evolution of the curve phi (default = 0)
'max_iter' - the maximum number of iterations to perform (default = 10)
'normforceflag' - normalizes the force term at every iteration (default = 1)
Example:
active_contour_chan_vese3d('verbose', 1);
Paper: "Minimizing Functionals: A Level Set Approach", A. I. Hanna, School of Computing Sciences, University of East Anglia, 2007.
URL: http://www2.cmp.uea.ac.uk/~aih/papers/MinimizingFunctionalsUsingLevelSets/MinimizingFunctionals-ALevelSetApproach_hanna.pdf
Dr. A. I. Hanna (2007)
C:\Users\AB\DArT_Toolshed\Toolboxes\VolumeAnalysisToolbox\3DGrowthAnalysisToolbox\src\volumeProcessingTool\activeContoursApplicationsJS
activeContourDemo2D.m
function varargout = active_contour_chan_vese2d(varargin)
A method that implements the Chan-Vese model applied to image
segmentation. This model is a special case of the Mumford-Shah model and
it tries to separate the image into regions based on intensities.
Default parameters:
'image' - the input image (default = 'pout.tif')
'phi' - the initial distance function (default = circular disk)
'lambda1' - weight of energy inside the contour (default = 0.5)
'lambda2' - weight of energy outside the contour (default = 0.5)
'mu' - weighting for the length of the contour (default = 1)
'nu' - weighting of area of the contour (default = 1)
'deltaT' - step size for the update of phi (default = 0.5, note: 0.01<=deltaT<=0.9)
'verbose' - shows the evolution of the curve phi (default = 0)
'max_iter' - the maximum number of iterations to perform (default = 10)
'normforceflag' - normalizes the force term at every iteration (default = 1)
Example:
active_contour_chan_vese2d('verbose', 1);
Paper: "Minimizing Functionals: A Level Set Approach", A. I. Hanna, School of Computing Sciences, University of East Anglia, 2007.
URL: http://www2.cmp.uea.ac.uk/~aih/papers/MinimizingFunctionalsUsingLevelSets/MinimizingFunctionals-ALevelSetApproach_hanna.pdf
Dr. A. I. Hanna (2007)
prepareGaussianDiskImage.m
prepareImages.m
Script to do misc. image preparation tasks for the images to be used in the active contour demo
C:\Users\AB\DArT_Toolshed\Toolboxes\VolumeAnalysisToolbox\3DGrowthAnalysisToolbox\src\volumeProcessingTool\clusterScriptsEarlyExamples
getActiveContourDefaultParameters.m
loadActiveContourParams.m
function varargout = loadActiveContourParams(varargin) Description: Function to load active contour parameter structure from disk. Author: Johann Strasser Date: 070926
loadVolumeActiveContourParams.m
saveActiveContourParams.m
function varargout = saveActiveContourParams(varargin) Description: Saves active contour parameters to a specified directory
saveVolumeActiveContourParams.m
function volume = saveVolumeActiveContourParams(volumeseriesDirectory, volume) Description: Saves active contour parameters of a volume. to disk. Author: Johann Strasser Date: 071213
C:\Users\AB\DArT_Toolshed\Toolboxes\VolumeAnalysisToolbox\3DGrowthAnalysisToolbox\src\volumeProcessingTool\sieves
volumeProcessingTool.m
volumeProcessingTool M-file for volumeProcessingTool.fig Description: Remark: The ouput argument is only used in debugging. All data are written to disk. Similarly no input except the project directory is required as all data are read from disk. Author: Johann Strasser Date: 070717