Functions - Alphabetical List

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

A

AbelPoissonKernel the Abel Poisson kernel
abs (vector3d) length of vector
add (crystalSymmetry) add additional symmetry operations to a crystal symmetry
adjustFigurePosition (mtexFigure) determine optimal size
affinetrans (EBSD) perform an affine transformation on spatial ebsd data
alignment (symmetry) return alignment of the reference frame as string, e.g. x||a, y||b*
allPairs all pairs of elements of x and y modulo permutation
allTriple all triple of elements of x and y modulo permutation
angle (fibre) angle fibre to orientation or fibre to fibre
angle (orientation) calculates rotational angle between orientations
angle (quaternion) calcualtes the rotational angle between rotations q1 and q2
angle (vector3d) angle between two vectors
angle_outer (quaternion) calcualtes the rotational angle between all rotations q1 and q2
angle_outer (vector3d) angle between two vectors Input v1, v2 - @vector3d
angleOrientationMapping Detailed explanation goes here
annotate annotate to a existing figure
antiSym (tensor) the antisymmetric part A = 0.5(T - T.') of a tensor
apply_recursivly apply cmd recursively to all file in a directory
ar2rgb compute rgb values from angle and radius
area (grain2d) calculates the area of a list of grains
argin_check check ar to be of class classes
arrow3d (vector3d) plot three dimensional arrows
aspectRatio (grain2d) aspectratio = length / width
assert_grid check for valid grid parameters
assertExt
axesDual (crystalSymmetry) return dual coordinate axes
axis (orientation) rotational axis of an misorientation or two orientations
axis (quaternion) rotational axis of the quaternion
axis2quat rotational axis, roational angle to Quaternion
axis2quat_outer rotational axis, roational angle to Quaternion
axisAngleOrientationMapping Detailed explanation goes here
axisAnglePlot
axisAngleSections
axisSector (orientationRegion) computes the sector of rotational axes for orientations within region

B

bandwidth (ODF) bandwidth of the ODF
basicHKL (crystalSymmetry) plot symmetry
BCV (orientation) biased cross validation
bingham_test (orientation) bingham test for spherical/prolat/oblat case
BinghamComponent (BinghamComponent)
BinghamODF defines a Bingham distributed ODF
binsearch binaer search for zero in a motonously increasing function
black2whiteColorMap Linear white to black gray-scale color map
blue2redColorMap creates a colormap, ranging from dark blue via white to dark red.
boundary (sphericalRegion) compute boundary points
boundarySize (grain2d) number of boundary segment
brassOrientation returns the cube orientation
bucketSearch n-d search of the closest vertex out of a set of vertices V
bumpKernel the bump kernel Detailed explanation goes here
BungePlot
BungeRGBOrientationMapping Detailed explanation goes here

C

c_hat return the second moments for bingham test
calc_flags check for optional flag
calcAngleDistribution (ODF) compute the angle distribution of an ODF or an MDF
calcAngleDistribution (orientation) calculate angle distribution
calcAngleDistribution (orientationRegion) compute the angle distribution of a uniform ODF for a crystal symmetry
calcAngleDistribution (symmetry) compute the angle distribution of a uniform ODF for a crystal symmetry
calcAxisDistribution (ODF) compute the axis distribution of an ODF or MDF
calcAxisDistribution (orientationRegion) compute the axis distribution of an uniform ODF or MDF
calcAxisDistribution (symmetry) compute the axis distribution of an uniform ODF or MDF
calcAxisVolume (ODF) amount of orientations with a specific misorientation axis
calcBario (DelaunaySO3) compute bariocentric coordinates for an orientation
calcBario (S2Triangulation)
calcBinghamODF (orientation) calculate ODF from individuel orientations via kernel density estimation
calcCluster (orientation) sort orientations into clusters
calcComponents (ODF) heuristic to find modal orientations
calcDelaunay (vector3d) compute the Delaynay triangulation for a spherical grid
calcDensity (vector3d) calculate a density function out of (weighted) unit vectors
calcError (ODF) calculate approximation error between two ODFs
calcError (PoleFigure) RP and mean square error
calcErrorPF (PoleFigure) error polefigure between meassured and recalculated pole figures
calcFEMODF (PoleFigure) PDF to ODF inversion
calcFourier (BinghamComponent) called by ODF/calcFourier
calcFourier (FourierComponent) called by ODF/calcFourier
calcFourier (ODF) compute Fourier coefficients of odf
calcFourier (femComponent) called by ODF/calcFourier
calcFourier (fibreComponent) called by ODF/calcFourier
calcFourier (uniformComponent) called by ODF/calcFourier
calcFourier (unimodalComponent) called by ODF/calcFourier
calcFourierODF (orientation) calculate ODF from individuel orientations via kernel density estimation
calcGND (EBSDsquare) compute the geometrically necessary dislocation
calcGrains (EBSD) grains reconstruction from 2d EBSD data
calcInvTaylor (orientation) Taylor factor from orientation gradient
calcKernel (orientation) compute an optimal kernel function for ODF estimation
calcKernelODF (orientation) calculate ODF from individuel orientations via kernel density estimation
calcMDF (FourierComponent) calculate the uncorrelated misorientation distribution function (MDF) from one or two ODF
calcMDF (ODF) calculate the uncorrelated misorientation distribution function (MDF) from one or two ODF
calcMDF (unimodalComponent) calculate the uncorrelated misorientation distribution function (MDF) from one or two ODF
calcMDF (orientation) computes an MDF from individuel orientations or misorientations
calcMeanDirection (grainBoundary) compute a smoothed direction that ignores staircasing
calcMIndex (ODF) M-index of Skemer et al.(2005) based on the difference between uncorrelated and uniform misorientation angle distributions
calcMIndex (orientation) TODO!!!
calcMisorientation (EBSD) calculate uncorrelated misorientations between two ebsd phases
calcModes (BinghamComponent) return the modes of the component
calcModes (ODF) heuristic to find modal orientations
calcModes (ODFComponent) return the modes of the component
calcModes (fibreComponent) return the modes of the component
calcModes (unimodalComponent) return the modes of the component
calcNormalization (PoleFigure) normalization of a meassured pole figure with respect to a second pole figure
calcODF (PoleFigure) PDF to ODF inversion
calcODF (orientation) computes an ODF from individuel orientations
calcOrientations (ODF) draw random orientations from ODF
calcParis (grain2d) Percentile Average Relative Indented Surface
calcPDF (BinghamComponent) called by pdf
calcPDF (FourierComponent) calculate pole figure from Fourier coefficients
calcPDF (ODF) calcPDF computed the PDF corresponding to an ODF
calcPDF (femComponent) called by pdf
calcPDF (fibreComponent) calculate pdf for fibre component
calcPDF (uniformComponent) calculate pdf
calcPDF (unimodalComponent) compute the pole density function for a given unimodal component
calcpdf_special (FourierComponent) compute the pdf for h = (theta,rhoh), r = (theta,rhor)
calcpdf_special3 (ODF) compute the pdf for h = (theta,rhoh), r = (theta,rhor)
calcPoleFigure (ODF) simulate pole figures from an ODF
calcPoleFigure (PoleFigure) simulate pole figure
calcQuadratureWeights (vector3d) compute the area of the Voronoi decomposition
calcQuat (symmetry) calculate quaternions for Laue groups
calcShearStress (tensor) shear stress
calcTaylor (tensor) compute Taylor factor and strain dependent orientation gradient
calcTensor (EBSD) compute the average tensor for an EBSD data set
calcTensor (FourierComponent) compute the average tensor for an ODF
calcTensor (ODF) compute the average tensor for an ODF
calcTensor (ODFComponent) compute the average tensor for an ODF
calcTensor (orientation) compute the average tensor for a vector of orientations
calcTriplePoints (grainBoundary) compute triple points
calcUnitCell compute the unit cell for an EBSD data set
calcVoronoi (quaternion) compute the the Voronoi decomposition for unit quaternions
calcVoronoi (vector3d) compute the area of the Voronoi decomposition
calcVoronoiArea (vector3d) compute the area of the Voronoi decomposition
call_extern execute extern program with arguments
cat (EBSD) overloads [ebsd1,ebsd2,ebsd3..]
cat (grain2d) implements [grain1, grain2]
cat (PoleFigure)
cat (Miller) concatenate lists of Miller indices to one list
cat (S2Grid)
cat (fibre)
cat (quaternion)
cat (rotation)
cat (slipSystem)
cat (vector3d)
cell2file write cellstring to file
centerOrientationMapping Detailed explanation goes here
centerSpecimen (ODF) rotatates an odf with specimen symmetry into its symmetry axes
centroid (grain2d) calculates the barycenters of the grain boundary
char (EBSD) ebsd -> char
char (ODF) odf -> char
char (uniformComponent) standard output
char (unimodalComponent) called by standard output
char (PoleFigure) standard output
char (Miller) Miller indece to string
char (SO3Grid) convert to char
char (crystalSymmetry) object -> string
char (quaternion) quaternion to char
char (rotation) quaternion to char
char (specimenSymmetry) object -> string
char (sphericalRegion) convert spherical region to char
char (tensor) tensor to char
char (vector3d) convert to char
ChebCoeff (FourierComponent) return Chebyshev coefficient of odf
check (DelaunaySO3) ignore this
check (symmetry) check symmetry
check_installation check whether all binaries are working properly
check_interfaces determine interface from file
check_option check for option in option list
checkEulerAngleConvention
checkInside (grain2d) check for points or grains to be inside a big grain
checkInside (S2Triangulation)
checkInside (orientationRegion) check for points to be inside the orientation region
checkInside (sphericalRegion) check for points to be inside the spherical region
checkOption check for option in option list
checkSymmetry (tensor)
ChristoffelTensor (tensor) Christoffel tensor of an elasticity tensor for a given direction
circle (vector3d) annotated a circle
cleanUp (orientationRegion) testing: cs = crystalSymmetry('222'); oR = cs.fundamentalRegion;
cleanUp (sphericalRegion)
ClebschGordan ClebschGordan.m by David Terr, Raytheon, 6-17-04 Modified on 11-9-04
ClebschGordanTensor A = [[1 1 -1];[1 1 1];[-1 1 1]];
CLim (mtexFigure) set color range for figures
clusterBreaker Recursively assigns points based on neighboring assignments If flag == 0, the point is fresh, 1, the point is set >1, the point belongs to a cluster that may have run into the recusion limit
coarser (S1Grid) makes S1Grid more coarse
colorbar (mtexFigure)
concentration (ODF) not yet implemeted
conformalPlot
conj (tensor) conjugate of a tensor
connectedComponents label connected componentes in an graph (adjacency matrix)
contour (vector3d) spherical contour plot
contour3s contour-slices
contourf (vector3d) spherical filled contour plot
conv (FourierComponent) convolute ODF with kernel psi
conv (ODF) convolute ODF with kernel psi
convertFigureRGB2ind default resolution
coolColorMap COOL Shades of cyan and magenta color map COOL(M) returns an M-by-3 matrix containing a "cool" colormap. COOL, by itself, is the same length as the current figure's colormap. If no figure exists, MATLAB creates one.
copy (S2Grid) copy certain condition from grid
copy (SO3Grid) copy nodes by indece
correct (PoleFigure) corrects polfigures for background and defocussing
cprintf CPRINTF convert an array of any data type to a 2D character array
cprproject_read
cross (quaternion) pointwise cross product of three quaternions
cross (vector3d) pointwise cross product of two vector3d
cross_outer (vector3d) pointwise cross product of two vector3d
crossCorrelation (orientation) computes the cross correlation for the kernel density estimator
crystalShape (crystalShape) a class representing crystal shapes.
crystalSymmetry (crystalSymmetry) constructor
CSL coincidence site lattice misorientations for cubic symmetry
ctranspose (orientation) inverse orientation
ctranspose (quaternion) transpose quaternion
ctranspose (tensor) conjugate of a tensor
ctranspose (vector3d) transpose vector
cubeOrientation returns the cube orientation
cunion disjoint union
customKernel defines a kernel function as a function of the rotational angle
cut2unitI

D

deformationTensor (slipSystem) deformation tensor
deg2dim dimension of the harmonic space up to order l
degree x * degree = x in standard arc measure
DelaunaySO3 (DelaunaySO3) Syntax
deLaValeePoussinKernel DELAVALEEPOUSSINKERNEL Summary of this class goes here Detailed explanation goes here
delete (S1Grid) delte points from S1Grid
delete (S2Grid) elilinates points from grid
delete (SO3Grid) clear nodes by indece Input SOG - @SO3Grid indece - int32
delete_option clear options in option list
det (vector3d) pointwise determinant or triple product of three vector3d
diag (tensor) convert rank 1 or rank 0 tensor into diagonal rank 2 tensor
diameter (grain2d) diameter of a grain longest distance between any two vertices of the grain boundary
dim2deg dimension to harmonic degree of Wiegner D functions
directionalMagnitude (tensor) magnitude of a tensor in direction v
DirichletKernel the Dirichlet kernel in the orientation space
discreteSample (ODF) draw a random sample
discreteSample (ODFComponent) draw a random sample
discreteSample (femComponent) draw a random sample
discreteSample (fibreComponent) evaluate an odf at orientation g
discreteSample (uniformComponent) draw a random sample
discreteSample (unimodalComponent) draw a random sample
discreteSample take a diskrete sample from a list of vectors, orientations, grains, EBSD
discretesample Samples from a discrete distribution
disjoint (symmetry) returns the disjoint of two symmetry groups
dislocationSystem (dislocationSystem) class representing dislocation systems
dislocationTensor (dislocationSystem) dislocation tensor
display (EBSD) standard output
display (grain2d) standard output
display (grainBoundary) standard output
display (triplePointList) standard output
display (BinghamComponent) standard output
display (FourierComponent) called by standard output
display (ODF) standard output
display (femComponent) called by standard output
display (fibreComponent) called by standard output
display (uniformComponent) standard output
display (unimodalComponent) called by standard output
display (PoleFigure) standard output
display (DelaunaySO3) standard output
display (Miller) standard output
display (S1Grid) standart output
display (S2Grid) standard output
display (SO3Grid) standard output
display (crystalSymmetry) standard output
display (fibre) standard output
display (orientation) standart output
display (orientationRegion) standard output
display (quaternion) standart output
display (rotation) standart output
display (tensor) standard output
display (vector3d) standard output
displayClass
dispLine (crystalSymmetry) display symmetry as a one-liner
dispLine (specimenSymmetry) display symmetry as a one-liner
dist (S1Grid) distance to all points of S1Grid
dist_outer (S1Grid) distance to all points of S1Grid
doclink
docmethods display all methods for a certain class
docopt DOCOPT Web browser for UNIX platforms. DOCOPT is an M-file that you or your system manager can edit to specify the Web browser to use with MATLAB. It is used for the WEB function with the -BROWSER option. It is also used for links to external Web sites from the the Help browser and from Web menu items. DOCOPT applies only to non-Macintosh UNIX platforms.
doHClustering (orientation) sort orientations into clusters
dot (Miller) inner product between two Miller indece
dot (orientation) compute minimum dot(o1,o2) modulo symmetry
dot (quaternion) inner product of quaternions g1 and g2
dot (rotation) compute rot1 . rot2
dot (vector3d) pointwise inner product
dot_angle (quaternion) compute minimum q1 . q2 modulo rotation about zaxis and angle omega
dot_outer (Miller) inner product between two Miller indece
dot_outer (SO3Grid) return outer inner product of all nodes within a eps neighborhood
dot_outer (orientation) dot_outer
dot_outer (quaternion) outer inner product between two quaternions
dot_outer (rotation) dot_outer
dot_outer (vector3d) outer dot product
double (S1Grid) convert to double
double (quaternion) quaternion to double
double (tensor) convert tensor values to matrix
double (vector3d) converts vector3d to double Input v - @vector3d Output x, y, z - double
drawNow (mtexFigure)
dspacing (Miller) space between crystal planes
dynOption class to add dynamic options to a static class Detailed explanation goes here
dynProp class to add dynamic properties to a static class Detailed explanation goes here

E

eangleProjection equal area projection
eareaProjection equal area projection
EBSD (EBSD) constructor
EBSDsquare (EBSDsquare) EBSD data on a rectangular grid. In contrast to arbitrary EBSD data the values are stored in a matrix.
edistProjection equal area projection
efopen file open with error message
eig (tensor) compute the eigenvalues and eigenvectors of a tensor
eig3 returns the largest eigenvalue of a symmetric 3x3 matrix
EinsteinSum (tensor) tensor multiplication according to Einstein summation
end (fibre) overloaded end function
end (quaternion) overloads end function
end (slipSystem) overloaded end function
end (tensor) overloaded end function
end (vector3d) overloaded end function
ensurecell ensures that v is a cell with size s
ensureCS (symmetry) ensures that an obj has the right crystal symmetry
ensureNonNeg remove small negative values
entropy (ODF) caclulate entropy of ODF
eq (grain2d)
eq (S1Grid) implements G1 == G2
eq (crystalSymmetry) check S1 == S2
eq (fibre) ? sS1 == sS2
eq (orientationRegion)
eq (quaternion) ? q1 == q2
eq (slipSystem) ? sS1 == sS2
eq (sphericalRegion)
eq (symmetry) check S1 == S2
eq (tensor) checks whether two tensors are equal
eq (vector3d) ? v1 == v2
equal check all elements of A to be equal
equispacedS2Grid defines an equispaced spherical grid
equispacedSO3Grid defines a equispaced grid in the orientation space
equivalentPerimeter (grain2d) returns the equivalent perimeter of grain-polygon
equivalentRadius (grain2d) returns the equivalent radius of grain-polygon
Euler (quaternion) quaternion to euler angle
euler2quat converts euler angle to quaternion
EulerAngleConvention
EulerCycles retrieve Euler cycles from an not oriented edge list
EulerTours find Euler tours in an adjacency matrix
eval (BinghamComponent) evaluate an odf at orientation g
eval (FourierComponent) evaluate odf using NSOFT
eval (ODF) evaluate an odf at orientation g
eval (femComponent) evaluate an odf at orientation ori
eval (fibreComponent) evaluate an odf at orientation g
eval (uniformComponent) evaluate an odf at orientation g
eval (unimodalComponent) evaluate sum of unimodal components at orientation g
evalkappa eigenvalues of orientation tensor to bingham distribution parameters
exp (orientation) exponential function
expm (tensor) matrix exponential of a tensor
export (EBSD) export EBSD data to a ascii file
export (ODF) export an ODF to an ASCII file
export (PoleFigure) export pole figure in an ASCII file
export (quaternion) export quaternions to a ascii file
export (vector3d) export quaternions to a ascii file
export_generic (ODF) export an ODF to an ASCII file
export_h5 (EBSD) export EBSD data to a ascii file
export_mtex (ODF) export an ODF into the MTEX format
export_VPSC (ODF) export an ODF to the VPSC format
export_VPSC (orientation) export individual orientations to the VPSC format
expquat matrix exponential to convert skew symmetric matrices into quaternions
extend (EBSD) returns the boundings of spatial EBSD data
extract_argoption extract options from option list
extract_data extract data
extract_kernel
extract_option extract options from option list
extract_SO3grid
extractOptions extract options from option list

F

factor (symmetry) factorizes s1 and s2 into l, d, r such that s1 = l * d and s2 = d * r
fclencurt Fast Clenshaw Curtis Quadrature
femComponent (femComponent) defines an ODF by finite elements
femODF defines an ODF by finite elements
fft_rho project rho to interval [-1,1)
fft_theta project theta to interval [0,0.5]
fibre (fibre) fibre is a class representing a fibre in orientation space. Examples are alpha, beta or gamma fibres. In general a fibre is defined by a crystal direction h of type <Miller_index.html Miller> and a specimen direction of type <vector3d_index.html vector3d>.
fibre2quat arbitrary quaternion q with q * h = r
fibreComponent (fibreComponent) defines an fibre symmetric component
fibreODF defines an fibre symmetric ODF
fibreVolume (ODF) ratio of orientations with a certain orientation
fibreVolume (orientation) ratio of orientations close to a certain fibre
fibreVonMisesFisherKernel
file2cell reads a file rowise into a cellstr
fill (EBSD) extrapolate spatial EBSD data by nearest neighbour for tetragonal lattice
fill (EBSDsquare) fill spatial EBSD data
fillByGrainId (EBSD) extrapolate spatial EBSD data by nearest neighbour for tetragonal lattice
find (S1Grid) find close points
find (S2Grid) return index of all points in a epsilon neighborhood of a vector
find (SO3Grid) return indece and distance of all nodes within a eps neighborhood
find (quaternion) return indece and distance of all nodes within a eps neighborhood
find (vector3d) return index of all points in a epsilon neighborhood of a vector
find_option find postions of the options in option_list
find_type parse arguments list for a specific type an returns the first occurance
findByLocation (EBSD) select EBSD data by spatial coordinates
findByLocation (grain2d) select a grain by spatial coordinates
findByOrientation (EBSD) select ebsd data by orientation
findByOrientation (grain2d) select grains by orientation
findOutlier (PoleFigure) find outliers in pole figures
findTetra (DelaunaySO3) find tetrahegon
fit_ellipse fit_ellipse - finds the best fit to an ellipse for the given set of points.
flip (grainBoundary) flip a boundary from phase1/phase2 to phase2/phase1
fliplr (EBSD) flip spatial ebsd-data from left to right
flipud (EBSD) flip spatial ebsd-data from upside down
FMC_Coarsen Performs one coarsening step.
FMC_interpret Interpretation of FMC data and grain assignment
FMC_MTEX setup Wnext
Fourier (FourierComponent) get Fourier coefficients of and ODF
Fourier (tensor) compute the Fourier coefficients of the tensor
FourierComponent (FourierComponent) defines an ODF component by its Fourier coefficients
FourierODF (ODF) compute FourierODF from another ODF
FourierODF defines an ODF by its Fourier coefficients
fundamentalRegion (symmetry) fundamental region in orientation space for a (pair) of symmetries
fundamentalRegion get the fundamental zone in orientation space for a symmetry
fundamentalRegionEuler (symmetry) get the fundamental region in Euler angles
fundamentalSector (symmetry) get the fundamental sector for a symmetry in the inverse pole figure

G

gammaSections
GaussWeierstrassKernel
gcm
generic_wizard
get_flag extract flag from option list
get_obj_fields
get_option extract option from option list
getCamera get xAxis and zAxis position from axis
getClass
getdata (S2Grid) return index of all points in a epsilon neighborhood of a vector
getDataCursorPos (mtexFigure) get the position and value of the data cursor
getFundamentalRegion (orientation) projects orientations to a fundamental region
getHoldState
getmem return total system memory in kb
getMinAxes (rotation)
getMTEXpref
getSubDirs getSubDirs - gets recursively all subdirectories of a given directory.
gossOrientation returns the cube orientation
grad (ODF) gradient of odf at orientation ori
grad (uniformComponent) gradient of the ODF at orientation g
grad (unimodalComponent) gradient at orientation g
grain2d (grain2d) two dimensional grains
grainBoundary (grainBoundary) grainBoundary list of grain boundaries in 2-D
gridify (EBSD) extend EBSD data to an grid
GridLength (S1Grid) return number of points
guessfibre try to find the fibre of to given rotations by finding the eigenvector of g_1*h = g_2*h -> (g_2^-1)*g_1* h = h -> R*h = (lambda)*h

H

halfQuadraticFilter haldQuadraticFilter uses the techniques elaborated half-quadratic minmization on manifolds to smooth EBSD data. Properties: alpha: regularisation parameter in [x,y] direction weight: function handle specified by the regularising function \varphi, @(t,eps), where eps is its parameter eps: Parameter for the weight tol: Tolerance for the gradient descent threshold: threshold for subgrain boundaries Methods: smooth: Applies the HQ minimization on the quaternions of the given orientations
hasHole (grain2d) test if a grain has a hole or not
hist (grain2d)
hist (ODF) calcualtes a histogram of ODF
HKLOrientationMapping defines an orientation mapping based on a certain inverse pole figure Detailed explanation goes here
homochoricPlot
horzcat (fibre) overloads [v1,v2,v3..]
horzcat (orientationRegion)
horzcat (quaternion) implements [q1,q2,q3..]
horzcat (slipSystem) overloads [v1,v2,v3..]
horzcat (sphericalRegion)
horzcat (tensor) overloads [T1,T2,T3..]
horzcat (vector3d) overloads [v1,v2,v3..]
hotColorMap HOT Black-red-yellow-white color map HOT(M) returns an M-by-3 matrix containing a "hot" colormap. HOT, by itself, is the same length as the current figure's colormap. If no figure exists, MATLAB creates one.
hr2quat arbitrary quaternion q with q * h = r
hsl2hsv
hsvColorMap HSV Hue-saturation-value color map HSV(M) returns an M-by-3 matrix containing an HSV colormap. HSV, by itself, is the same length as the current figure's colormap. If no figure exists, MATLAB creates one.
HSVOrientationMapping defines an orientation mapping based on a certain inverse pole figure Detailed explanation goes here converts crystal directions to rgb values

I

id2ind (EBSD) find ind such that ebsd.id(ind) == id
idquaternion the identical rotation - quaternion(1,0,0,0)
idRotation the identical rotation
import_wizard
ind2char calculates coordinate from one index i - index s - size of matrix
infimalConvolutionFilter matrix-valued image with the TV-norm. \argmin_u{\|u-u_0\|_2^2 + \lambda \|\nabla u\|_{2,1} + \mu \|H u\|_{2,1}}, \lambda,\mu > 0 Written by Johannes Persch, Ronny Bergmann, 09.06.2015 function ma_val_im_reg_2nd_ord minimzes the second order model of a OUTPUT: u_hat: computed minimizer diff: differences of u and v between two successive iterations
inpolygon (EBSD) checks which ebsd data are within given polygon
interp (vector3d) spherical interpolation - including some smoothing
intersect (grainBoundary) length of a boundary segment
inv (quaternion) quaternion of the inverse roation
inv (tensor) inverse of a tensor
inversion the inversion - reflection at the origin
ipdfAngleOrientationMapping defines an orientation mapping based on a certain inverse pole figure Detailed explanation goes here
ipdfCenterOrientationMapping Detailed explanation goes here
ipdfHSVOrientationMapping defines an orientation mapping based on a certain inverse pole figure Detailed explanation goes here
ipdfOrientationMapping defines an orientation mapping based on a certain inverse pole figure Detailed explanation goes here
ipfSections
isappr check double == double
isempty (PoleFigure) overloads length
isempty (fibre) overloads isempty
isempty (quaternion) overloads isempty
isempty (slipSystem) overloads isempty
isempty (vector3d) overloads isempty
isempty_cell isempty for cells
iseven check double mod 2 == 0
isFourier (ODF) check whether odf is given by Fourier coefficients
isImproper (rotation)
isLower (sphericalRegion)
isMisorientation (orientation) check whether o is a misorientation
isnan (quaternion) check for nan values
isnull ckeck double == 0
isOctave
isOutlier (PoleFigure) find outliers in pole figures
isPerp (vector3d) check whether v1 and v2 are orthogonal
ispos check double > 0
isRGB
isTwinning (grainBoundary) Syntax
isUpper (sphericalRegion)

K

K_symmetrised (kernel) evaluate kernel modulo symmetries
KAM (EBSD) intragranular average misorientation angle per orientation
kde Reliable and extremely fast kernel density estimator for one-dimensional data; Gaussian kernel is assumed and the bandwidth is chosen automatically; Unlike many other implementations, this one is immune to problems caused by multimodal densities with widely separated modes (see example). The estimation does not deteriorate for multimodal densities, because we never assume a parametric model for the data. INPUTS: data - a vector of data from which the density estimate is constructed; n - the number of mesh points used in the uniform discretization of the interval [MIN, MAX]; n has to be a power of two; if n is not a power of two, then n is rounded up to the next power of two, i.e., n is set to n=2^ceil(log2(n)); the default value of n is n=2^12; MIN, MAX - defines the interval [MIN,MAX] on which the density estimate is constructed; the default values of MIN and MAX are: MIN=min(data)-Range/10 and MAX=max(data)+Range/10, where Range=max(data)-min(data); OUTPUTS: bandwidth - the optimal bandwidth (Gaussian kernel assumed); density - column vector of length 'n' with the values of the density estimate at the grid points; xmesh - the grid over which the density estimate is computed; - If no output is requested, then the code automatically plots a graph of the density estimate. cdf - column vector of length 'n' with the values of the cdf Reference: Kernel density estimation via diffusion Z. I. Botev, J. F. Grotowski, and D. P. Kroese (2010) Annals of Statistics, Volume 38, Number 5, pages 2916-2957.
kernel (kernel)
KLCV (orientation) Kullback Leibler cross validation for optimal kernel estimation
KuwaharaFilter

L

LaboTeXColorMap return LaboTeX colormap
LaplaceKernel
Laue (symmetry) return the corresponding Laue group
LaueName (symmetry) get Laue name
ldivide (orientation) o .\ v
legendre0 Legendrepolynome bis zur Odnung N und gibt sie als Matrix zur�ck erste Dimension -> Ordnung zweite Dimension -> x
length (fibre) overloads length
length (quaternion) overloads length
length (slipSystem) overloads length
length (symmetry) number of symmetry elements
length (tensor) returns the number of tensors
length (vector3d) overloads length
line (rotation) draw rotations connected by lines
line (vector3d) Syntax
linearCompressibility (tensor) computes the linear compressibility of an elasticity tensor
load_generic load file using import data and txt2mat
loadCIF import crystal symmetry from cif file
loadData import PoleFigure, EBSD, and ODF data
loadEBSD import ebsd data
loadEBSD_ACOM read ACOM files (converted from *.res ASTAR)
loadEBSD_ang read TSL *.ang file
loadEBSD_brukertxt read Bruker *.txt file
loadEBSD_crc interface for Oxford Chanel 5 crc and cpr EBSD data files
loadEBSD_csv
loadEBSD_ctf read HKL *.ctf file
loadEBSD_dream3d
loadEBSD_ebsdimage Check extension
loadEBSD_generic load ebsd data from generic text files
loadEBSD_h5
loadEBSD_hdf5 Read rotations
loadEBSD_osc
loadEBSD_Oxfordcsv
loadEBSD_sor load LaboTex *.sor file
loadGrainSet_hdf5 Read EBSD
loadHelper helps to load data-matrix with ColumnNames restricts also data according to conventions (e.g. >4pi)
loadODF import ebsd data
loadODF_generic load pole figure data from (alpha,beta,gamma) files
loadODF_VPSC
loadOrientation import orientation data from data files
loadOrientation_DRex
loadOrientation_generic load Orientation data from generic text files
loadPHL
loadPoleFigure import pole figure data
loadPoleFigure_aachen import data fom aachen ptx file
loadPoleFigure_aachen_exp import data fom aachen_exp file
loadPoleFigure_ana import data fom ana file
loadPoleFigure_beartex import data fom BeaTex file
loadPoleFigure_dubna load dubna cnv file
loadPoleFigure_geesthacht load ptx file
loadPoleFigure_generic load pole figure data from (theta,rho,intensity) files
loadPoleFigure_gpol
loadPoleFigure_ibm import data fom ibm file
loadPoleFigure_juelich load juelich data format
loadPoleFigure_labotex load labotex pole figure data
loadPoleFigure_nja
loadPoleFigure_out1 import polfigure-data form Graz
loadPoleFigure_philips load philips *.txt file
loadPoleFigure_plf load plf file
loadPoleFigure_popla import data fom Popla file
loadPoleFigure_pwd load D5000 powder data file
loadPoleFigure_rigaku import data fom Rigaku SamrtLab txt file
loadPoleFigure_rigaku_dat load *.dat files of rigaku devices
loadPoleFigure_rigaku_txt import data fom ana file
loadPoleFigure_rigaku_txt2 import data fom ana file
loadPoleFigure_rw1 import data from Philip's Xpert binary file format rw1
loadPoleFigure_scintag import data fom scintag ascii file
loadPoleFigure_siemens load D5000 data file
loadPoleFigure_slc load *.txt file with regular grid
loadPoleFigure_uxd import data fom ana file
loadPoleFigure_xrd import data fom aachen xrd file
loadPoleFigure_xrdml load xrdMeasurement (xrdml) file
loadTensor import Tensor data
loadTensor_generic load a Tensor from a file
loadTensor_mpod import Tensor data
loadTensor_P load a Tensor from a file
loadVector3d import ebsd data
loadVector3d_generic load pole figure data from (alpha,beta,gamma) files
localOrientationGrid define a equispaced grid localized to a center orientation
log (orientation) the inverse of the exponential map
log (quaternion) project a quaternion into the tangential space
logm (quaternion) the dislocation tensor for a rotation
logm (tensor) matrix logarithm of a tensor
LSCV (orientation) least squares cross valiadation

M

mapPlot class to handle spatial plots of EBSD data and grains
mat2quat converts direction cosine matrix to quaternion
matrix (quaternion) quaternion to direction cosine matrix conversion converts direction cosine matrix to quaternion
matrix (rotation) quaternion to direction cosine matrix conversion converts direction cosine matrix to quaternion
matrix (tensor) return tensor as a matrix
max (ODF) heuristic to find local modal orientations
max (PoleFigure) maximum of two pole figures or the maximum of a single polefigure
max (S1Grid) return maximum value
max (tensor)
maxAngle (orientationRegion) get the maximum angle of the fundamental region
maxAngle (symmetry) get the maximum angle of the fundamental region
maxpdf (ODF) returns the maximum orientation in a polefigure
mean (ODF) expected value of an ODF
mean (PoleFigure) mean of pole figure intensities
mean (orientation) mean of a list of orientations, principle axes and moments of inertia
mean (quaternion) mean of a list of quaternions, principle axes and moments of inertia
mean (vector3d) computes the mean vector
mean_CS (quaternion) fast mean of
meanFilter implements a convolution filter for quaternion
medianFilter
merge (grain2d) merge grains along special grain boundaries
mhyper multivariat hypergeometric function 1F1(1/2,p/2, kappa)
Miller (Miller) define a crystal direction by Miller indice
Miller2quat calculate quaternion from Miller indece
min (PoleFigure) minimum of two pole figures or the minimum of a single polefigure
min (S1Grid) return maximum value
min (tensor)
minAngle (orientationRegion) get the minimum angle of the boundary of the fundamental region
minus (ODF) superposeing two ODFs
minus (PoleFigure) implements pf1 - pf2
minus (S1Grid)
minus (quaternion) overloads minus
minus (tensor) add two tensors
minus (vector3d) overload minus
mix2 mix2 sample ODF
mldivide (orientation) o \ v
mldivide (quaternion)
mldivide (rotation) o \ v
mpower (quaternion) q^n
mPrime (slipSystem) m' parameter from Luster and Morris in 1995
mrdivide (ODF) scaling of the ODF
mrdivide (PoleFigure) implements pf1 ./ b and a ./ pf2
mrdivide (quaternion) scalar division
mrdivide (tensor) implements T / S
mtex_assert
mtex_path return install dir of mtex
mtexCifPath returns the default path to crystallographic information files (CIF)
mtexColorbar overide buildin Matlab colorbar function
mtexColorMap define an MTEX colormap
mtexdata load of data provided with mtex and often used in documentation
mtexDataPath returns the default path to mtex sample data
mtexdegchar returns the degree character
mtexEBSDPath returns the default path to EBSD data files
mtexFigure (mtexFigure) class to handles figures with equaly sized axes
MTEXmenu show up MTEX menu
mtexODFPath returns the default path to ODF-files
mtexPoleFigurePath returns the default path to PoleFigure data files
mtexTensorPath returns the default path to tensor-files
mtimes (EBSD) rotating the ebsd data by a certain rotation
mtimes (ODF) scaling of the ODF
mtimes (PoleFigure) scaling of PoleFigures, implements pf1 * b and a * pf2
mtimes (SO3Grid) outer quaternion multiplication
mtimes (crystalShape)
mtimes (orientation) orientation times Miller and orientation times orientation
mtimes (quaternion) quaternionen multiplication q1 * q2
mtimes (rotation) r = a * b
mtimes (tensor) implements T1 * T2
mtimes (vector3d) scalar multiplication
multiplicityPerpZ (symmetry) maximum angle rho
multiplicityZ (symmetry) maximum angle rho

N

n2str num2str with exact zero
nadjacent Returns the adjacency matrix of the n-neighbours.
nanmax FORMAT: [Y,IDX] = NANMAX(A,DIM,[B])
nanmean FORMAT: Y = NANMEAN(X,DIM)
nanmedian FORMAT: Y = NANMEDIAN(X,DIM)
nanmin FORMAT: [Y,IDX] = NANMIN(A,DIM,[B])
nanplus
nanquaternion the identical rotation - quaternion(1,0,0,0)
nansum FORMAT: Y = NANSUM(X,DIM)
ndims (quaternion) overloads ndims
ne (grain2d)
ne (fibre) ? sS1 ~= sS2
ne (orientationRegion)
ne (quaternion) q1 ~= q2 ?
ne (slipSystem) ? sS1 ~= sS2
ne (sphericalRegion)
ne (tensor) checks whether two tensors are not equal
ne (vector3d) ? v1 == v2
neighbors (grain2d) returns the number of neighboring grains
neuralgas (ODF) attempt to distribute measure-sites equally according to invers polefigure density (experimental)
newer_version check matlab version
newMapPlot
newMtexFigure
newODFSectionPlot generate a new ODF section plot
newOrientationPlot prepare a 3d orientation plot
newSphericalPlot split plot in upper and lower hemisphere
nextAxis (mtexFigure) go to next plot
nextstyle NEXTSTYLE Get next plot linespec [L,C,M] = NEXTSTYLE(AX) gets the next line style, color and marker for plotting from the ColorOrder and LineStyleOrder of axes AX.
nfold (symmetry) maximal n-fold of symmetry axes
niceEuler (orientation) orientation to euler angle
noisepf (PoleFigure) simulate diffraction counts
norm (FourierComponent) caclulate texture index of ODF
norm (ODF) caclulate texture index of ODF
norm (quaternion) quaternion norm sqrt(a^2+b^2+c^2+c^2)
norm (vector3d) vector norm
normalize (PoleFigure) normalization of a meassured pole figure with respect to an ODF
normalize (quaternion) normalize quaternion
normalize (vector3d) normalize a vector
numel (tensor) returns the number of tensors
NWSE

O

ODF (ODF)
ODFSections (ODFSections) ODFSECTIONS Summary of this class goes here Detailed explanation goes here
omegaSections
option2str transforms option list to comma separated list
optiondraw apply options to handle
optionplot plot y against x using the options in varargin
orientation (fibre) generate a list of orientation out of a fibre
orientation (orientation) orientation - class representing orientations
orientationMapping ORIENTATIONMAPPING Summary of this class goes here Detailed explanation goes here
orientationPlot ODFSECTIONS
orientationRegion (orientationRegion) sphericalRegion implements a region in orientation space The region is bounded by planes normal to quaternions N i.e., all quaternions q inside a region satisfy the condition dot(q, N) <= 0 or dot(-q, N) <= 0 for all N
orth (vector3d) an arbitrary orthogonal vector
orthographicProjection equal area projection
orthProj (vector3d)

P

parents (orientation) variants of an orientation relationship
parseXML PARSEXML Convert XML file to a MATLAB structure.
parulaColorMap PARULA Blue-green-orange-yellow color map PARULA(M) returns an M-by-3 matrix containing a colormap. The colors begin with dark purplish-blue and blue, range through green and orange, and end with bright yellow. PARULA is named after a bird, the tropical parula, which has these colors.
patalaOrientationMapping (patalaOrientationMapping) converts misorientations to rgb values as described in
pauseline
pcolor (vector3d) spherical contour plot
pdfMatrix (femComponent) called by pdf
pdfMatrix (DelaunaySO3) called by pdf
perimeter (grain2d) calculates the perimeter of a grain without or without inclusions
perimeter (grainBoundary) boundary length per grain including holes
permute (quaternion) overloads permute
permute (rotation) overloads permute
perp (vector3d) conmpute an vector best orthogonal to a list of directions
perturbe (quaternion) pertube data randomly by epsilon
pfSections
phaseList handles a list of phases
phi1Sections
phi2Sections
PhiSections
plainProjection sphericalProjection
planeIntersect (vector3d) pointwise determinant or triple product of three vector3d
plot (EBSD) spatial EBSD plot
plot (grain2d) colorize grains
plot (grainBoundary) plot grain boundaries
plot (triplePointList) plot grain boundaries
plot (ODF) plots odf
plot (PoleFigure) plot pole figure
plot (ODFSections) plot data into ODF sections
plot (S1Grid) plot grid
plot (S2Triangulation) find all edges given by vertex i and vertex j
plot (crystalShape) colorize grains
plot (fibre)
plot (orientation) annotate a orientation to an existing plot
plot (orientationRegion) plots a spherical region
plot (quaternion)
plot (sphericalRegion) plots a spherical region
plot (symmetry) visualize symmetry elements according to international table
plot (tensor) plot a tensor T
plot (vector3d) plot three dimensional vector
plot (kernel) plot the kernel function
plot3d (ODF) plots odf
plot3d (vector3d) plot spherical data
plot_zero_range (PoleFigure) implements the zero range method
plota2east set the default plot direction of the x-axis
plota2north set the default plot direction of the x-axis
plota2south set the default plot direction of the x-axis
plota2west set the default plot direction of the x-axis
plotAngleDistribution plot axis distribution
plotAxisDistribution plot axis distribution
plotb2east set the default plot direction of the x-axis
plotb2north set the default plot direction of the x-axis
plotb2south set the default plot direction of the x-axis
plotb2west set the default plot direction of the x-axis
plotCustom (vector3d) Syntax plotcustom(v,@(x,y) drawCommand(x,y)) %
plotDiff (ODF) difference plot between two odfs or an odf and a pole figure
plotDiff (PoleFigure) difference plot between two pole figures or an odf and a pole figure
plotEllipse plot multiple ellipses
plotEmptySphere plots white sphere
plotFibre (ODF) plot odf along a fibre
plotFourier (ODF) plots Fourier coefficients of the odf
plotFourier (kernel) plot the Chybeyshev coefficients of the kernel function
plotHKL (crystalSymmetry) plot symmetry
plotIPDF (ODF) plot inverse pole figures
plotIPDF (fibre) plot orientations into inverse pole figures
plotIPDF (orientation) plot orientations into inverse pole figures
plotPDF (ODF) plot pole figures
plotPDF (fibre) plot a fibre into pole figures
plotPDF (orientation) plot orientations into pole figures
plotPDF (kernel) plot Radon transformed kernel
plotS2Grid create a regular S2Grid for plotting
plotSection (ODF) plot ODF sections
plotSection (orientation) plot orientations to ODF sections
plotSO3Grid give a regular grid in orientation space
plotUVW (crystalSymmetry) plot symmetry
plotx2east set the default plot direction of the x-axis
plotx2north set the default plot direction of the x-axis
plotx2south set the default plot direction of the x-axis
plotx2west set the default plot direction of the x-axis
plotzIntoPlane set the default plot direction of the z-axis
plotzOutOfPlane set the default plot direction of the z-axis
plus (ODF) superposeing two ODFs
plus (PoleFigure) implements pf1 + pf2
plus (S1Grid)
plus (crystalShape) crystal shape should be first argument
plus (quaternion) pointwise addition
plus (tensor) add two tensors
plus (vector3d) poitwise addition
PoissonRatio (tensor) computes the Poisson ratio of an elasticity tensor
polar (S2Grid) polar coordinates of S2Grid
polar (vector3d) cartesian to spherical coordinates Input v - @vector3d Output theta - polar angle rho - azimuthal angle r - radius
polarCoordinates (sphericalRegion) compute polar coordinates of with respect to a spherical region
PoleFigure (PoleFigure)
power (orientation) ori.^n
power (quaternion) q.^n
power (rotation) r.^n
principalComponents (grain2d) returns the principalcomponents of grain polygon, without Holes
prod (quaternion) overloads q1 * q2 * q3
progress display progress
project (ODFSections) project orientation to ODF sections used by plotSection
project2EulerFR (orientation) projects orientation to a fundamental region
project2EulerFR (quaternion) projects quaternions to a fundamental region
project2FundamentalRegion (Miller) projects vectors to the fundamental sector of the inverse pole figure
project2FundamentalRegion (orientation) projects orientation to a fundamental region
project2FundamentalRegion (quaternion) projects quaternions to a fundamental region
project2FundamentalRegion (rotation) projects rotation to a fundamental region
project2FundamentalRegion (vector3d) projects vectors to the fundamental sector of the inverse pole figure
properGroup (symmetry) return the corresponding Laue group
properSubGroup (symmetry) return the corresponding Laue group

Q

qmatrix (quaternion) returns the quaternion multiplication matrix
qq (quaternion) returns w * q' * q
qqplot (orientation) quantile-quantile of misorientation angle against random angular misorientation
quadratureS2Grid Syntax [S2G, W, M2] = quadratureS2Grid(M) quadrature grid of type gauss [S2G, W, M2] = quadratureS2Grid(M, 'chebyshev') quadrature grid of type chebyshev
quadric (tensor) quadric
quantile (ODF) quantile orientations of an ODF
quantile n percent quantile of x
quaternion (quaternion)
quaternionPlot
quiver (EBSD) plot directions at ebsd centers
quiver (grain2d) plot directions at grain centers
quiver (grainBoundary) plot directions at grain boundaries
quiver (vector3d) Syntax quiver(v,d)
quiver3 (vector3d) Syntax quiver(v,d)
qwarning warning with option to stop

R

randp randp(lambda) returns Poisson distributed Vector with mean lambda
randq returns random quaternions
randv
range RANGE Sample range. Y = RANGE(X) returns the range of the values in X. For a vector input, Y is the difference between the maximum and minimum values. For a matrix input, Y is a vector containing the range for each column. For N-D arrays, RANGE operates along the first non-singleton dimension.
rdivide (ODF) scaling of the ODF
rdivide (PoleFigure) implements pf1 ./ b and a ./ pf2
rdivide (quaternion) scalar division
rdivide (tensor)
rdivide (vector3d) scalar division
real (quaternion) real-part of of quaternion
real (tensor)
red2blueColorMap creates a colormap, ranging from dark blue via white to dark red.
reduce (EBSD) reduce ebsd data by a factor
refine (DelaunaySO3) step 1: compute center of any two orientation connected by an edge
refine (S1Grid) refine S1Grid
refine (S2Grid) refine S2Grid
refine (vector3d) refine vectors
reflection defines a reflection at plane with normal n
region (Miller) return spherical region associated to a set of crystal directions
region (vector3d)
regularS2Grid Syntax regularS2Grid('points',[72 19]) regularS2Grid('resolution',[5*degree 2.5*degree]) regularS2Grid('theta',theta,'rho',rho)
regularSO3Grid regular grid in Euler orientation space
reorder (grainBoundary) nicely reorder grain boundaries
rep implements R like "rep" elementeweise
repcell equivalent to repmat for cells
repmat (crystalShape) duplicate the faces
repmat (quaternion) overloads repmat
repmat (rotation) overloads repmat
repmat (vector3d) overloads repmat
reshape (quaternion) overloads reshape
reshape (rotation) overloads reshape
reshape (vector3d) overloads reshape
residualBurgersVector (slipSystem) compute the Schmid factor
restrict2Lower (sphericalRegion)
restrict2Upper (sphericalRegion)
restrictEBSD_ang read file header
rhoInside
rhoRange (sphericalRegion) compute range of the polar angle of a spherical region
RK_symmetrised (kernel) sum Radon trasformed kernel
rmallappdata removes all figure appdata
Rodrigues (quaternion) quaternion to rodrigues representation
rodrigues2quat
RodriguesPlot
rotate (EBSD) rotate EBSD orientations or spatial data around point of origin
rotate (BinghamComponent) rotate component
rotate (FourierComponent) called by ODF/rotate
rotate (ODF) rotate ODF
rotate (femComponent) called by ODF/rotate
rotate (fibreComponent) called by ODF/rotate
rotate (uniformComponent) called by ODF/rotate
rotate (unimodalComponent) called by ODF/rotate
rotate (PoleFigure) rotates pole figures by a certain rotation
rotate (Miller) rotate crystal directions
rotate (S2Triangulation)
rotate (crystalShape) rotate a crystal shape by an rotation or orientation
rotate (orientationRegion) rotate of a orientation region
rotate (slipSystem) rotate slip system
rotate (sphericalRegion) rotate of a spherical region
rotate (tensor) rotate a tensor by a list of rotations
rotate (vector3d) rotate vector3d by rotation or orientation
rotate_outer (Miller) rotate crystal directions
rotate_outer (crystalShape) rotate a crystal shape by an rotation or orientation
rotate_outer (slipSystem) rotate slip system
rotate_outer (tensor) rotate a tensor by a list of rotations
rotate_outer (vector3d) rotate vector3d by quaternion
rotation (rotation) defines an rotation
rotation_special (symmetry) returns symmetry elements different from rotation about c-axis
round (Miller) tries to round miller indizes to greatest common divisor
round2Miller (orientation) find lattice alignements for arbitrary misorientations

S

S1Grid (S1Grid)
S2Grid (S2Grid) Syntax S2Grid(theta,rho) % fills a Sphere with N--nodes regularS2Grid(...) % construct regular polar and azimuthal spacing equispacedS2Grid(...) % construct equispaced nodes
S2Triangulation (S2Triangulation) a class represeneting a triangulation on the sphere
SantaFe the SantaFe-sample ODF
save_sparse convert sparse matrix to jc, ir, pr
saveEBSD_hdf5 Save EBSD object to HDF5 format
saveFigure save figure as graphics file
saveGrainSet_hdf5 Save GrainSet object to HDF5 format
scale (PoleFigure) scale polefigure by a factor
scaleBar Inserts a scale bar on the current ebsd or grain map.
scatter (Miller) plot Miller indece
scatter (orientation) plots orientations in 3d
scatter (quaternion) plot function
scatter (vector3d) Syntax scatter(v) % plot the directions v scatter(v,data) % colorize directions according to data scatter(v,'label',text) % plot text below markers scatter(v,'label',text,'textaboveMarker') % plot text above markers
scatter3d (vector3d) plot spherical data
SchmidFactor (slipSystem) compute the Schmid factor
SchmidTensor (vector3d) computes the Schmidt tensor
sectionLabels
segLength (grainBoundary) length of a boundary segment
select (PoleFigure) select PoleFigures
selectMaxbyColumn find maximum in each row
selectMaxbyRow find maximum in each column
selectMinbyColumn find minimum in each column
selectMinbyRow find minimum in each row
selectPolygon select a polygon by mouse
set_default_option set option in option list if not yet present
set_option set option in option list
setCamera set Camera according to xAxis and zAxis position
setColorRange set color range for figures
setMTEXpref
setNull set approx zero to exact zero
setOption set option in option list
setSubSet (quaternion) indexing of quaternions
shapeFactor (grain2d) calculates the shapefactor of the grain-polygon, without Holes
shearModulus (tensor) shear modulus for an elasticity tensor
shift (EBSD) shift spatial ebsd-data about (x,y)
shift (S1Grid) shifts S1Grid by delta
sigmaSections
size (fibre) overloads size
size (quaternion) overloads size
size (slipSystem) overloads size
size (tensor) overloads size
size (vector3d) overloads size
size2str convert size to string
slipSystem (slipSystem) class representing slip systems
slope (ODF) | grad(r) |
smooth (EBSD) smooth spatial EBSD
smooth (EBSDsquare) smooth spatial EBSD data
smooth (grain2d) constraint laplacian smoothing of grains
smooth (BinghamComponent) smooth ODF component
smooth (FourierComponent) smooth ODF component
smooth (ODF) smooth ODF
smooth (femComponent) smooth ODF component
smooth (fibreComponent) smooth ODF component
smooth (uniformComponent) smooth ODF component
smooth (unimodalComponent) smooth ODF component
smooth (Miller) plot Miller indece
smooth (vector3d) Syntax
smoothn SMOOTHN Robust spline smoothing for 1-D to N-D data. SMOOTHN provides a fast, automatized and robust discretized spline smoothing for data of arbitrary dimension.
SO3Grid (SO3Grid) Syntax S3G = SO3Grid(nodes,CS,SS) S3G = SO3Grid(points,CS,SS) S3G = SO3Grid(resolution,CS,SS)
SobolevKernel
sparse (vector3d)
sparseConcat
spatialProfile (EBSD) select EBSD data along line segments
specimenSymmetry (specimenSymmetry) defines a specimen symmetry
sphereVolume (orientation) ratio of orientations with a certain orientation
sphericalClebschGordan use global wigner3j
sphericalPlot sphericalPlot is responsible for visualizing spherical data
sphericalProjection sphericalProjection
sphericalRegion (sphericalRegion) sphericalRegion implements a region on the sphere The region is bounded by small circles given by there normal vectors and the maximum inner product, i.e., all points v inside a region satisfy the conditions dot(v, N) <= alpha
sphericalY spherical harmonics of degree l
splineFilter smoothes quaternions by projecting them into tangential space and performing there smoothing spline approximation
splitdata make n - partitions of a list, returns its indices
spy (SO3Grid) spy distance matrix
SquareSingularityKernel
steepestDescent (ODF) find maximum with steepest descent
steepestDescentX (ODF) find maximum with steepest descent
strainTensor
stressTensor
string2Miller converts string to Miller indece
subGrid (S1Grid) epsilon - neighborhood of a point in the grid
subGrid (S2Grid) subgrid
subGrid (SO3Grid) sub-SO3Grid as epsilon neigborhood of a node
submatrix B = A(ind) with size as A if possible
subsasgn (EBSD) overloads subsasgn
subsasgn (grain2d) overloads subsasgn
subsasgn (grainBoundary) overloads subsasgn
subsasgn (triplePointList) overloads subsasgn
subsasgn (PoleFigure) overloads subsasgn
subsasgn (S2Grid) overloads subsasgn
subsasgn (SO3Grid) overloads subsasgn
subsasgn (quaternion) overloads subsasgn
subsasgn (rotation) overloads subsasgn
subsasgn (slipSystem) overloads subsasgn
subsasgn (tensor) overloads subsasgn
subsasgn (vector3d) overloads subsasgn
subSet (EBSD) indexing of EBSD data
subSet (grain2d) Input grains - @grain2d ind -
subSet (grainBoundary) restrict boundary
subSet (triplePointList) restrict boundary
subSet (fibre) subindex vector3d
subSet (quaternion) indexing of quaternions
subSet (rotation) indexing of rotation
subSet (slipSystem) subindex vector3d
subSet (vector3d) subindex vector3d
subsind (EBSD) subindexing of EBSD data
subsind (EBSDsquare) subindexing of EBSD data
subsref (EBSD) indexing of EBSD data
subsref (grain2d) implements grains(1:3)
subsref (grainBoundary) implements gB(1:10)
subsref (triplePointList) implements tP(1:10)
subsref (PoleFigure) overide polefigure() and polefigure{}
subsref (S2Grid) overloads subsref
subsref (SO3Grid) overloads subsref
subsref (crystalSymmetry) overloads subsref
subsref (fibre) overloads subsref
subsref (quaternion) overloads subsref
subsref (rotation) overloads subsref
subsref (slipSystem) overloads subsref
subsref (symmetry) overloads subsref
subsref (tensor) overloads subsref
subsref (vector3d) overloads subsref
sum (quaternion) overloads sum
sum (tensor) sum over all tensors allong dimension 1
sum (vector3d) sum of vectors
surf (Miller) Syntax
surf (vector3d) Syntax
switchUnit returns the closest length to a known unit. For example, 10e3m will give 10km.
sym (tensor) the symmetric part S = 0.5(T + T.') of a tensor
symmetrise (Miller) directions symmetrically equivalent to m
symmetrise (dislocationSystem) find all symmetrically equivalent slips systems
symmetrise (fibre) all crystallographically equivalent fibres
symmetrise (orientation) all crystallographically equivalent orientations
symmetrise (quaternion) symmetrcially equivalent orientations
symmetrise (slipSystem) find all symmetrically equivalent slips systems
symmetrise (tensor) symmetrise a tensor according to its crystal symmetry
symmetrise (vector3d) symmetrcially equivalent directions and its multiple
symmetry (symmetry) Supported Symmetries

T

tensor (tensor)
tensorSize (tensor) overloads size
text (grain2d) plot directions at grain centers
text (Miller) plot Miller indece
text (vector3d) display a text in a spherical plot
text3 (vector3d) plot three dimensional arrows
textureindex (ODF) caclulate texture index of ODF
times (ODF) scaling of the ODF
times (PoleFigure) implements pf1 .* b and a .* pf2
times (crystalShape)
times (orientation) vec = ori .* Miller
times (quaternion) quaternion .* quaternion and quaternion .* vector3d
times (rotation) r = a .* b
times (tensor) multiply a tensor by a scalar
times (vector3d) .* - componenwtise multiplication
times_outer
trace (slipSystem) trace of the slip plane in the surface normal to n
trace (tensor) compute the trace of a rank 2 tensor
transform (tensor) transform a tensor to a given crystal frame
transformationMatrix (crystalSymmetry) compute the transformation matrix from cs1 to cs2
transformReferenceFrame (Miller) change reference frame while keeping hkl or uvw
transformReferenceFrame (orientation) change reference frame of an orientation
transformReferenceFrame (tensor) set properties of a tensor variable
transpose (fibre) transpose list of slipSystem
transpose (quaternion) transpose array of quaternions
transpose (rotation) transpose array of rotations
transpose (slipSystem) transpose list of slipSystem
transpose (tensor) transpose a list of a tensors
transpose (vector3d) transpose vector
triplePointList (triplePointList) grainBoundary list of grain boundaries in 2-D
TSLOrientationMapping orientation mapping as it is used by TSL and HKL software

U

uiimport overload standard MATLAB uiimport
uminus (ODF) superposeing two ODFs
uminus (PoleFigure) implements -pf
uminus (quaternion) overload unitary minus
uminus (rotation) implements -rotation
uminus (slipSystem) overloads unitary minus
uminus (vector3d) overloads unitary minus
uniformComponent (uniformComponent)
uniformODF get crystal and specimen symmetry
unimodalComponent (unimodalComponent)
unimodalODF define a unimodal ODF
union (PoleFigure) crytsallographic direction to one
union (symmetry) returns the union of two symmetry groups
unique (PoleFigure) remove dublicated points in a polefigure
unique (Miller) disjoint list of Miller indices
unique (orientation) disjoint list of quaternions
unique (quaternion) disjoint list of quaternions
unique (rotation) disjoint list of rotations
unique (vector3d) disjoint list of vectors
updateUnitCell (EBSD) this function should be called after the spatial coordinates of an EBSD data set have been modified
UpDown

V

variants (orientation) variants of an orientation relationship
varlink link to a variable
vdisp
vec2cell
vec42quat returns a quaternion q with q u_1 = v1 and q u2 = v2
vector3d (vector3d)
velocity (tensor) computes the elastic wave velocity(km/s) from the elastic stiffness Cijkl tensor and density (g/cm3)
vertcat (fibre) overloads [v1,v2,v3..]
vertcat (quaternion) implements [q1;q2;q3..]
vertcat (slipSystem) overloads [v1,v2,v3..]
vertcat (tensor) overloads [T1,T2,T3..]
vertcat (vector3d) overloads [v1,v2,v3..]
viridisColorMap
Voigt (tensor)
volume (ODF) ratio of orientations with a certain orientation
volume (ODFComponent) get resolution
volume (uniformComponent) for large angles or specimen symmetry take the quadrature based algorithm
volume (unimodalComponent) for large angles or specimen symmetry take the quadrature based algorithm
volume (orientation) ratio of orientations with a certain orientation
volume (orientationRegion) volume of an orientation region
volume (sphericalRegion) volume of a spherical region
volume (kernel)
volumeCompressibility (tensor) computes the volume compressibility of an elasticity tensor
vonMisesFisherKernel

W

white2blackColorMap gray Linear gray-scale color map
WhiteJetColorMap
Wigner3j Compute the Wigner 3j symbol using the Racah formula.
Wigner3j_new %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Wigner3jPrecomputed
WignerD Wigner-D function
wignerD2 spherical harmonics of degree l
write_cell write cell string to text file
writedouble write to file

X

xnum2str convert number to string
xticklabel_rotate Rotate XTickLabel
xvector vector (1,0,0)

Y

YoungsModulus (tensor) Young's modulus for an elasticity tensor
yvector vector (0,1,0)

Z

zeroRange (PoleFigure) implements the zero range method
zip_mtex zip mtex for publishing (on website)
zvector vector (0,0,1)