MTEX Changelog

MTEX 7.0 xx/2026 - New Features

This is the first release that uses AI. This allowed us to implement many long lasting ideas.

Grain Reconstruction

Grain reconstruction has been entirely rewritten to give better results, be faster and be more easy to control. The general syntax is now

[grains, ebsd] = calcGrains(ebsd,'angle',10*degree,'minPixel',5,'alpha',3.1)

and allows for three simple parameters to tune the reconstruction

This is explained in detail in here and here. For highly deformed materials we greatly improved the Fast Multiscale Clustering method.

We have now also a method to clean up pseudo symmetries in EBSD maps using the command

[ebsd,grains] = cleanUpPseudoSym(ebsd,grains,mori,'threshold',1.5)

Along with grain reconstruction we also greatly improved grain boundary smoothing which is now done with the command

grains = smoothBoundary(grains)

The command smoothBoundary allows for several backends which are explained in detail here.

Much Better EBSD Import

Eventually we now have a full functional import wizard for EBSD maps that allows to scroll through your data files, adjust reference system alignment by inspecting ipf maps and pole figures. We put a lot of effort in getting all the different conventions right for all the formats on the market, i.e. from Bruker, EDAX, Oxford, and ThermoFisher. In this process we changed the default plotting convention to y↓→x, i.e. the current standard among all vendors. This default can be easily changed by

ebsd.how2plot = 'y↑→x';

Additionally, we now support multiple data sets per file and allow to import all additional scans that might be present in your file.

Imported Data Comes on Its Grid

EBSD.load now returns an EBSDsquare or an EBSDhex whenever the measurements sit on one lattice, instead of a plain list that had to be gridifyed by hand. Almost every scan is a complete raster, so this is what you get for almost every file: the map is stored as a matrix, ebsd(i,j) addresses a scan position, and plotting and denoising no longer rebuild the raster on every call.

Data that would lose measurements by being gridded - two of them falling into the same lattice cell, or positions too irregular to span a raster - is never gridded and comes back as a list with a warning saying why. A plain list can also be asked for explicitly

ebsd = EBSD.load(fname,'noGrid')     % this import
setMTEXpref('gridifyOnImport',false) % every import

Both representations are accepted everywhere, and EBSD(ebsd) and gridify convert between them at any time. Note that putting data on a grid reorders it - the matrix layout fixes the first dimension to y while a .ctf or .ang runs x fastest - so ebsd(k) is in general no longer line k of the file. The original ids are kept in ebsd.oldId. See Square and Hex Grids.

One syntax had to go for this: ebsd(x,y) used to be the measurement closest to the coordinate (x,y) on a list, while on a gridded map the very same expression is the pixel in row x and column y. Since almost every file now arrives gridded, that silent difference would decide itself by the data rather than by the script, so ebsd(x,y) is an error now. Ask for the coordinate by name

ebsd('xy',x,y)   % the measurement closest to (x,y), grid or list
ebsd(i,j)        % the pixel in row i and column j, gridded map only

EBSD Analysis No Longer Needs a Grid

Computations that used to require gridify now work on any EBSD - a plain list, a phase subset, or a gridded map alike. This concerns the orientation gradient and everything built on it: curvature, calcGND and the gradient method of weightedBurgersVec.

kappa = curvature(ebsd)      % no ebsd.gridify needed
gnd   = calcGND(ebsd,dS)

They are computed on the virtual lattice MTEX derives from the unit cell, so they also work for grids that are rotated or sheared with respect to the x/y axes, which the previous matrix based implementation could not do at all - ebsd.gradientX raised an error unless a grid direction happened to lie along an axis. calcGND additionally exists for hexagonal grids now; there simply was no hexagonal implementation before.

fill, smooth, interp and weightedBurgersVec keep the class and shape they were given. Previously fill and smooth turned a plain EBSD into an EBSDsquare, and weightedBurgersVec returned a result shaped like the grid rather than like the input.

Both grid classes now also accept a rotated grid. EBSDhex in particular no longer stores dHex and isRowAlignment - those could express only two orientations - but derives them, together with offset, dx and dy, from the unit cell and the pixel positions.

Corrections worth knowing

Much Faster Plotting of EBSD Maps

Plotting EBSD and grain maps is now orders of magnitude faster. It supports multiple backends that allow for fast plotting of hexagonal or strongly deformed pixel layouts. The micronbar has been largely improved to include also a small pictogram of the reference system.

Approximation, Sampling and Clustering

sF   = S2FunMLS(nodes,values,'degree',3)
ori  = optimalSample(odf,10000)
[ori,c] = optimalSample(odf,500)   % optimize the weights, too
[c,center] = calcCluster(ori)
odf  = calcODFIterative(pf,'halfwidth',5*degree)

Rotations, Tangent Spaces and Vector Valued Functions

Two new pages describe the geometry MTEX is built upon. Rotation Representations compares Rodrigues, homochoric and cubochoric vectors and The Tangent Space the left and the right representation of a tangent vector. A SO3TangentVector now stores the rotation it is attached to, so switching between both representations needs no orientation passed along

t = odf.grad(ori); right(t)   % t knows ori, no second argument needed

What used to be a multivariate function is now a vector valued function and arrays of them are handled like any other MATLAB array.

MTEX 7.0 xx/2026 - Technical Changes

Grain Reconstruction

calcGrains covers small grain removal, alpha shapes and gridded as well as arbitrarily placed data in a single call. Its second output replaces the previous ebsd.grainId = ... assignment and marks pixels belonging to no grain - not indexed or removed by 'minPixel' - by grainId == 0. All boundary criteria are objects of type grainBoundaryCriterion (gbcAngle, gbcSoft, gbcFMC, gbcVariants, gbcCustom), so any per pixel property may be segmented and every phase may get a threshold of its own

grains = calcGrains(ebsd,'angle',{10*degree,15*degree}) % one per phase
grains = calcGrains(ebsd,gbcCustom(ebsd.bc,10))  % segment by band contrast
grains = calcGrains(ebsd,'soft')                 % a soft threshold

Fast multiscale clustering gbcFMC - the criterion for deformed material where no single threshold angle works - has been rewritten. It judges two clusters by their misorientation against their own internal spread, fits a lattice curvature so that a bent grain is not mistaken for a scattered one, and clusters each phase separately, which lifts the adjusted Rand index on a benchmark of deformed maps from 0.84 to 0.96 at a third of the runtime. Note that calcGrains(ebsd,'fmc',cmaha) used to fall back to angle thresholding without saying so

grains = calcGrains(ebsd,'fmc',0.5,'minPixel',10,'verbose')

The new data set mtexdata EMSphinx illustrates this in Grain Reconstruction. Advanced Grain Reconstruction shows how to write a criterion of your own, Markovian Clustering the second way of turning one into grains. Two new commands complete the picture

gbnd = calcGBND(grains.boundary('Fo','Fo'),ebsd('Fo'),'halfwidth',10*degree)
gbcd = calcGBND(gB,grains('Fo'),moriRef)   % for a fixed misorientation
gbnd = calcGBND(grains3.boundary)          % 3d, specimen coordinates
[ebsd,grains] = cleanUpPseudoSym(ebsd,grains,mori,'threshold',1.5)

Grain Boundaries in Walk Order

The segments of a grainBoundary are not an unordered list anymore. They are sorted into chains - maximal runs of segments joined at vertices where exactly two segments meet - so that consecutive segments share a vertex. Any other vertex is a junction and terminates a chain. Each chain occupies a contiguous block of rows and is oriented such that the grain in gB.grainId(:,1) lies to the left of the walk direction

gB = grains.boundary
gB.chainId, gB.chainSize, gB.isChainStart, gB.isChainEnd, gB.isClosed
gB.arcLength, gB.chainLength   % length along and of the chain
gB.chainV                      % vertex ids, chains separated by NaN

This is what allows to coarsen or to refine a boundary as a curve instead of as a bag of segments. All of the following keep the junctions exactly where they are, so which grains touch, and where, is unchanged

What used to be smooth(grains) is called smoothBoundary(grains) now - smooth on an EBSD denoises orientations, something entirely different - and it performs all three steps by default: simplify at d/sqrt(2), d the pixel spacing, which removes the grid and nothing else, refine, and only then the Laplacian smoothing it used to do on its own, which without the first two cuts the corners off a curve

grains = smoothBoundary(grains,5)
grains = smoothBoundary(grains,5,'noSimplify','noRefine')   % as before

The old name still works and still does the old thing, so a script written against it keeps its grain areas and its segment count. Since the first two steps change the number of segments, switch them off wherever gB.ebsdId is read per segment.

Which algorithm smooths is a choice now, made by passing a boundaryFilter - the same pattern as the EBSDFilter of smooth(ebsd,F)

grains = smoothBoundary(grains,taubinFilter)
grains = smoothBoundary(grains,curvatureFilter('smoothingLength',3))

laplaceFilter is the default and unchanged, taubinFilter unshrinks after every pass where a Laplacian shrinks without bound, curvatureFilter replaces the iteration by a single sparse solve whose knob is a length rather than an iteration count, and huberFilter keeps a genuinely faceted boundary faceted. Advanced Grain Smoothing compares them.

EBSD Import

All HDF5 flavours are handled by one json driven interface loadEBSD_h5, so no format has to be guessed and a new vendor is a matter of a json description rather than of a new interface. The import wizard is started by import_wizard and exports the import as a script

ebsd = EBSD.load('data.h5')                  % no format guessing needed
ebsd = EBSD.load('data.h5','dataSet',2)      % or 'dataSet','Area 2'
ebsd = EBSD.load('data.h5oina','dataSet','EBSD') % not the post processed data
ebsd = EBSD.load('data.h5','headerOnly')     % phases, header and data sets
ebsd = EBSD.load('data.ctf','EulerCorrection',rotation.byEuler(pi,0,0))

The formats ang, osc, oh5 and edaxh5 may all hold the very same map, but were interpreted differently. They now agree on the alignment between Euler angle and map reference frame, on the crystal axes alignment used by EDAX - x parallel to a for triclinic, trigonal and hexagonal lattices, now available for any symmetry by the option 'EDAX' - and on the point group of the phases, where ang and osc used to report the Laue group 622 instead of 6/mmm and 432 instead of m-3m. As the setting is not stored in the file, the most common setting 2 is assumed instead of leaving the Euler angles uncorrected - state one of 'setting',1 to 'setting',4 yourself, or switch the correction off by 'setting',0

ebsd = EBSD.load('data.edaxh5','setting',3)  % not the assumed setting 2
cs = crystalSymmetry('321',[4.9 4.9 5.4],'EDAX')   % x // a

Phases of Bruker files keep their International Tables number and atomic basis in cs.opt.spaceId and cs.opt.atoms. Fixed along the way: ang files whose header contains a stray carriage return - as written by some EDAX exports - silently lost their first data point.

Plotting EBSD Maps

EBSD and grain maps are drawn through three backends - imagesc, surf and patch. An axis aligned square grid goes to imagesc, any other square grid to surf, a hexagonal grid to patch, and inverse pole figure colors are precomputed via spherical lookup tables. Only patch draws one unit cell per pixel, which is what made large maps slow, so the routing may be overruled by 'backend' and the exact unit cells are still available by 'exact'

plot(ebsd,ebsd.orientations)                 % fast, the new default
plot(ebsd,ebsd.orientations,'exact')         % exact unit cells, as before
plot(ebsd,ebsd.orientations,'backend','patch')

The micron bar has been rewritten as a scaleBar object - it follows the plotting convention, rescales while zooming and takes options

plot(ebsd,'Location','nw','SBBackgroundColor','k','SBLineColor','w','Length',50)

Reference Frame Annotations

On top of the micron bar a box indicates how the specimen reference frame is aligned on screen - an arrow for every axis with a component in the screen plane, a circled dot or cross for the one pointing out of or into it, exactly as in the string form of plottingConvention. It follows the data when the map is reoriented, e.g. by setView.

What used to be reserved to pole figures now happens on every spherical plot that is not given in crystal coordinates as well - the axes of the reference frame are annotated with the axes names of the frame the data lives in: X, Y, Z by default, X1, Y1, Z1 for the measurement frame of the instrument, RD, TD, ND once the rolling frame rules the session (see Named Reference Frames below). This includes vector3d and S2Fun plots, sigmaSections and pfSections, spherical densities as returned by calcGBND or calcDensity, and specimenSymmetry. Plots in crystal coordinates - Miller, inverse pole figures, ipfSections, color keys, single crystal tensors - keep their Miller indices at the vertices of the fundamental sector instead. Both are customized by the same pfAnnotations preference that pole figures always used, and switched off per plot or for the session

pfAnnotations = @(varargin) text([vector3d.X,vector3d.Y],{'RD','ND'},...
  'BackgroundColor','w','tag','axesLabels',varargin{:});
setMTEXpref('pfAnnotations',pfAnnotations);

plot(vector3d.rand(100),'noLabel')
plot(ebsd,ebsd.orientations,'refFrame','off')
setMTEXpref('showRefFrame','off')

The Default Plotting Convention

The new default y↓→x is plottingConvention.ij - x to east, y to south and z into the screen - as SEM images are displayed and nearly every EBSD import states anyway. Pole figures are not affected, spherical plots align themselves with the hemisphere they show. A plottingConvention is stated as a string, each axis followed or preceded by the direction it points to on screen

ebsd.how2plot = 'y↑→x'            % also 'x←↑y', 'z⊙→x', ASCII 'y^->x'

Plotting conventions are carried by reference frames: data plotted the default way follows the session's default frame, hence changing the default convention also turns data imported before

plotx2east                                             % turns all data
plottingConvention.default('y↑→x')                     % the same by a string
pC = plottingConvention.default; pC.east = yvector; pC.makeDefault

A convention assigned to a single object becomes an own reference frame of that object and stays untouched by later changes of the default.

Named Reference Frames

Behind the conventions sits a new class referenceFrame that answers "what coordinate system is this data expressed in". A frame carries an identity, named axes and the plotting convention its data is drawn in; crystalSymmetry and specimenSymmetry delegate their frame data (crystal axes, how2plot) to the frame they hold. Specimen frames come as named session instances

specimenFrame.specimen      % the generic frame, axes X, Y, Z - the default
specimenFrame.measurement   % the instrument frame, axes X1, Y1, Z1
specimenFrame.rolling       % RD, TD, ND - RD north, TD west
specimenFrame.geological    % N, E, D

and any of them can take over the session by

specimenFrame.rolling.makeDefault

after which maps, pole figures and the micron bar annotate RD / TD / ND and plot in the rolling convention - no manual label definition needed. Every data class shows the frame it lives in at the top of its display, e.g. EBSD (Y1↓→X1) or PoleFigure (TD←RD↑); a crystal frame displays its alignment (Xa) and the resulting convention in crystal directions (⊙c→a).

Rotating data by an orientation now moves it from the crystal to the specimen frame (or back): the result adopts the new frame but never claims the orientation's symmetry, and mixing frames raises an error instead of silently producing numbers in an undefined coordinate system. Conventions loaded from .mat files are decided by the container: an EBSD or PoleFigure applies the convention its positions were saved with to the whole session, individual vectors keep theirs private. Scripted environments that run many independent jobs in one session can restore the pristine state by

referenceFrame.reset

Data without any symmetry can now state the frame it lives in: the trivial group carrying a frame is a first class citizen, obtained from a symmetry by cs.stripSym or directly from a frame by

crystalSymmetry(cF)    % the trivial group on the crystal frame cF
specimenSymmetry(sF)

Extrema and samples of a spherical function expressed in a crystal frame - for instance the deliberately unsymmetrised boundary normal distribution of calcGBND - therefore come back as Miller with proper crystal indices

[value,pos] = max(gbnd)   % pos is a Miller now

Along the same lines the compatibility checks behind orientation products and SO3Fun arithmetic compare the reference frames the coordinates are expressed in, rather than the symmetry groups: aligned crystal frames combine even when the groups differ, a compatible frame transition is absorbed automatically, and a wrong sided product - an orientation applied to data in specimen coordinates - is an error now instead of a warning.

Rotating a function drops a symmetry it destroys - now consistently

Rotating an SO3Fun or an SO3VectorField by a rotation which is not one of its own symmetry elements destroys that symmetry, so the group is dropped and only the reference frame kept. The twelve rotate methods implementing this had drifted into three different tests for "is there a symmetry to lose", and they disagree for every non centrosymmetric point group of order two - 2, m, -4 and friends. Concretely

cs  = crystalSymmetry('2',[1 2 3],[90 100 90]*degree);
odf = unimodalODF(orientation.rand(cs));
rot = rotation.byAxisAngle(vector3d(1,2,3),37*degree);
odf = rotate(odf,rot,'right');

warned and dropped the symmetry in SO3FunHarmonic, and silently kept the - by then false - claim of 2 symmetry in SO3FunComposition and the SO3VectorField classes. All of them now warn and drop, which is the correct behaviour: the rotated function really is no longer 2 symmetric. If you relied on the old silence, the symmetry was already wrong; a result that should keep its group has to be rotated by a symmetry element.

Orientation products follow the same rule

rot * ori acts in the specimen frame and so can only destroy the specimen symmetry; ori * rot acts in the crystal frame and destroys the crystal one. Both now drop the group and keep the frame, through the very same helper. Previously the product kept the group and merely warned, and the test for "is this a symmetry element" was a quaternion dot above 0.99 - which is a rotation angle of 16.2 degree, so any rotation up to sixteen degrees passed as a symmetry element and not even the warning fired.

This was visible in Detection of Sample Symmetry, which rotates a sample by 15.6 degree in order to destroy its orthotropic symmetry deliberately. The claim of 222 survived the rotation, the ODF estimated from those orientations was symmetrised with it, and centerSpecimen then had nothing left to find: it returned the identity, an error of the full 15.6 degree. It now recovers the rotation to 0.8 degree.

A plotting convention belongs to a reference frame

There are exactly three ways to say how something should be aligned on screen, and a plotting convention is now always a property of a reference frame rather than of a data object

plot(ebsd,'how2plot','y↑→x')       % this one plot
plottingConvention.default('y↑→x') % the whole session
ebsd.frame = specimenFrame.rolling % move the data to a named frame

The first of these is new. Assigning a convention to the data itself, ebsd.how2plot = 'y↑→x', used to attach a private copy of the session frame to that one object - a frame that carried the session frame's name and axis labels, was indistinguishable from it in every display, and then silently stopped following it. how2plot is therefore read only on every class but referenceFrame, where the convention actually lives. Reading it is unchanged, and ebsd.frame = [] still means "follow the session again".

Importing data no longer changes how the session plots

A file describes its own data, not your screen. Loading an .mat file, and mtexdata, no longer repoint the session convention. An import may still state which frame the data lives in - Oxford data lands in specimenFrame.measurement with the axes X1, Y1, Z1 - and a convention you pass yourself still applies, since that is your choice and not the file's.

Documentation pages that want a particular alignment now say so, which they previously inherited invisibly from mtexdata.

This also applies to S2Fun.smiley, which used to carry its own convention so the face always read right - a page that shows it now declares plottingConvention.default('y↑→x') like any other.

Color Keys Say What They Are

Color keys used to display as MATLAB's dump of their properties, in which every interesting one read [1x1 crystalSymmetry]. They now show the pair of reference systems they map between in the header, the way an orientation does, and below it only the settings that distinguish them from a default key

ipfKey = ipfColorKey (Titanium (Alpha) → y↓→x)

   ipfDirection : (0,0,1)
   direction key: HSVDirectionKey

A directional color key additionally states which way round its colors run, written in the axes of its frame - ⊙c→a for a crystal key. That layout belongs to the frame of the symmetry and not to the session.

The property inversePoleFigureDirection is called ipfDirection now, and 'ipfDirection' works as a plot option beside the old spelling

plot(ebsd,ebsd.orientations,'ipfDirection',vector3d.X)

The long name keeps working as an alias, so existing scripts are unaffected.

Approximation, Sampling and Clustering

Moving least squares approximation supports vector valued data, outlier detection, smoothly varying support radii and Voronoi weights, and planarColorKey turns any pair of scalar properties into a color

SO3F = SO3FunMLS(ori,values,'delta',5*degree,'detectOutliers')
cK   = planarColorKey(winter,'colorModel','white');
rgb  = cK.property2color(grains.longAxis,grains.aspectRatio);

Tangent Spaces and Vector Valued Functions

A SO3TangentVector stores the symmetries along with the rotation it is attached to, and for SO3VectorFieldHarmonic the switch between the left and the right representation is performed directly on the harmonic coefficients. Arrays of vector valued functions support cat, reshape, permute, squeeze, transpose, indexing and assignment - which worked for SO3FunHarmonic only and now works for SO3FunHandle and SO3FunRBF as well. SO3VectorField comes with the arithmetic +,-,.*,./ together with dot and normSquare, and a SO3FunRBF draws its pole figures, inverse pole figures and sections directly instead of through a harmonic approximation.

Syntax Changes

ebsd.CSList(1) = notIndexed('amorphous',[0.5 0.5 0.5])

Renamed and Removed

Minor Additions

Under the Hood

MTEX 6.1 10/2025

MTEX 6.1 does not come with major new features but with tons of speed ups and bug fixes. A lot of effort has been put into increasing the stability of the provided mex files. On startup MTEX automatically checks whether all mex files are installed. If not it attempts to download them from Github. If this fails as well, i.e. because your antivirus program intervenes, it tries to compile those mex files from source. The relevant commands are

We will not list all speedups and minor improvements but only highlight which syntax has changed.

MTEX 6.0 10/2024

MTEX 6.0 is major release that includes numerous new features and internal changes.

Full 3d-Grains

With MTEX 6.0 three dimensional grain networks can be imported from Neper or Dream 3d and analyzed in a similar powerful way as you are used to do it with 2d grains. Have a look at 3d-grain operations and 3d-grain properties for more information.

Pseudo 3d EBSD and Grain maps

Additionally, all previous 2d-classes like EBSD, grain2d, grainBoundary are not longer restricted to the xy-plane. For example it is now possible to consider EBSD maps that represent the three faces of a cube. To make this possible, multiple changes at the core of MTEX had to be introduced:

Free three dimensional plotting of EBSD maps, pole figures, etc.

how2plot = plottingConvention
how2plot.outOfScreen = ebsd.N
how2plot.east = yvector
plot(ebsd, how2plot)

would plot an EBSD map with its normal direction out of the screen and the y-vector pointing to north. * A default plotting convention can be stored directly in the EBSD or grain variable via

ebsd.plottingConvention = how2plot

Interface to Neper Neper is an open source software package for 3d polycrystal generation and meshing. It is now possible to call Neper from within MTEX, simulate micro-structures, generated slices through a 3d volume and import those slices into MTEX. Have a look at NeperInterface for more information.

Misc Changes

MTEX 5.11.0 3/2024

MTEX 5.11 will be the last release before MTEX 6.0. It significantly improves grain reconstruction from 2d EBSD data.

Much Faster Grain Reconstruction

Thanks to using the jc_voronoi as tessellation method and some addition speedups grain reconstruction is now more than 10 times faster then previously. The method used for Voronoi tessellation is now specified in mtex_settings by the option 'VoronoiMethod'. You may want to set this option to 'qhull' if you experience problems with the 'jcvoronoi' engine.

Much Better Grain Reconstruction

With MTEX 5.11 MTEX uses alpha shapes to determine the shape of the grains in the presence of large unindexed regions. Those alpha shapes are controlled by a single parameter 'alpha' with specifies to which extend indexed regions are allowed to grow into not indexed regions. Have a look at grain reconstruction for an illustration of the new method.

Vector Fields in Orientation Space

Functionality of Vector Fields in Orientation Space has been greatly extended. It includes now functions to compute the divergence div(vF), the curl curl(vF) and the antiderivative of a vector field vF on orientation space. This new functionality can be used to efficiently model texture evolution by numerically solving the continuity equation as it is demonstrated for the single slip model. Crucial for this approach is the new command doEulerStep which updates an ODF or a list of orientation according to a vector field an orientation space which may be given e.g. by the Taylor model.

Lankford Parameter

The command calcLankford allows for the computation of the Lankford or R-value. A full discussion of the corresponding analysis can be found here.

Transformation ODF

The command variants(p2c,odfParent) takes now as a second input a parent ODF and return the child ODF under the assumption that all variants appear with the same frequency. This is in more detail explained in the section Transformation Texture.

Inner Planes in Crystal Shapes

Using the commands plotInnerFace, plot(cS,sS) and arrow3d it is now possible to plot internal lattice planes, directions or slip systems into the crystal shape. This is explained in more detail at Crystal Shapes.

Numerous minor improvements and bug fixes

MTEX 5.10.1 9/2023

This is mainly a bug fix release.

MTEX 5.10.0 5/2023

Weighted Burgers Vector

With the function weightedBurgersVec(ebsd) it is now possible to compute the weighted burgers vector both, using the integral approach as well as the differential approach.

Bain Group Determination

The function calcVariantId now returns an id for the variant, the packet and the Bain group. The usage of this function is demonstrated here.

Numerous minor addon, speed improvements, bug fixes

MTEX 5.9.0 2/2023

Habit Plane Detection

MTEX 5.9 includes powerful functions for the determination of predominant habit planes and habit plane distributions. For the setting of a fully transformed microstructure the are described in the paper plane determination from reconstructed parent phase orientation maps. Those functions include

Orientation dependent functions

The orientation distribution function (ODF) describes the relative volume of crystal orientations within a material. As such it is a function that associates to each orientation a number with unit mrd (multiples of random distribution). However, in material science many other orientation depended functions are of importance, e.g., the Taylor factor with respect to some outer strain depends on the local orientation. While ODFs have ever since been at the heart of MTEX, this release is the first one that includes full support for orientation dependent functions. Those functions are called SO3Fun and behave similar to spherical functions S2Fun. In particular one can

While implementing these new features we also significantly speed up all operations related with ODF operations. A full documentation of these new features can be found here.

MTEX 5.8.2 11/2022

This is mainly a bug fix release. New functionalities include

MTEX 5.8.0 01/2022

MTEX 5.8 improves further on parent grain reconstruction by implementing the novel variant graph algorithm which is faster and more accurate than the previous grain graph algorithm.

Improved parent grain reconstruction

Along with the new reconstruction algorithm the following new features have been implemented:

Misc Changes

MTEX 5.7.0 05/2021

MTEX 5.7 improves on parent grain reconstruction. Changes include:

Improved parent grain reconstruction

Other Changes

MTEX 5.6.1 03/2021

This is mainly a bug fix release.

MTEX 5.6.0 01/2021

MTEX 5.6 greatly simplifies parent grain reconstruction by introducing the class parentGrainReconstructor. During the reconstruction procedure this class keeps track of the correspondence between measured child grains and the reconstructed parent grains. It provides the following functions for recovering parent orientations which can be applied multiple times and in any order to achieve the best possible reconstruction.

The usage of this new class is demonstrated in Beta Titanium Reconstruction and Parent Martensite Reconstruction.

Compatibility fixes

MTEX 5.6 fixes several incompatibilities with MATLAB versions earlier then 2019b.

MTEX 5.5.0 11/2020

Orientation Embedding

Orientational embeddings are tensorial representations of orientations with the specific property that each class of symmetrically equivalent orientations has a unique tensor representation. In contrast to the well known representation by Rodrigues vectors those embeddings do not suffer from boundary effects, i.e., the Euclidean distance between the tensors is always close to the misorientation angle. This allows to lift any method that works for multivariate data to orientations. More details of this representation can be found in the chapter orientation embeddings and the paper

Low Angle Boundaries

With MTEX 5.5 we make low angle grain boundary analysis much more straight forward by allowing to pass to the command calcGrains two thresholds, i.e.,

grains = calcGrains(ebsd,'threshold',[10*degree 1*degree])

generates grains bounded by high angle grain boundaries with a threshold of 10 degree and inner low angle boundaries with an threshold of 1 degree. The latter ones are stored as grains.innerBoundary. In order to estimate the density of inner boundaries per grain the commands subBoundaryLength and subBoundarySize have been introduced. The documentation page Subgrain Boundaries describes the analysis of low angle boundaries in more detail.

New Functionalities

ebsd(ind).orientations = orientation.byEuler(0,0,0,CSNew)
ebsd(ind).CS = CSNew

plot([vector3d.Z, vector3d.Z + 0.5 * vector3d.rand],'arrow')

Important Bug Fixes

MTEX 5.4.0 7/2020

Parent Grain Reconstruction

MTEX now includes a number of functions for variant analysis and to recover parent grain structure. Examples include beta phase reconstruction in Titanium and Martensite reconstruction from Austenite grains. The reconstruction is mainly build around the following new commands

New Functionalities

MTEX 5.3.1 6/2020

New Functions

Bug Fixes

MTEX 5.3.0 4/2020

MTEX 5.3 is a humble release without big shiny improvements. On the other hand is has seen some internal changes which lead to significant speed improvements in some functions. Technically speaking the class symmetry is not derived from rotation anymore but is a handle class. From the users perspective almost no change will be noticed. Developers should replace length(cs) by numSym(cs).

Much Better and Faster Halfquadratic Filter

Denoising of EBSD data using the halfQuadraticFilter is now about 10 times faster, handles outliers much better and runs native on hexagonal grids.

New Functions

MTEX 5.2.3 11/2019

MTEX 5.2.0 10/2019

New Documentation

MTEX got a new homepage which was needed to include a much more exhaustive online documentation which has now

The new documentation is not yet perfect though we are working hard to improve it. That's why we are extremely happy for everybody who contributes additions to the documentation. This includes the correction of spelling errors, theoretical parts, examples etc. Check out how to contribute to the documentation.

More Colors

All plotting commands in MTEX support now much more colors. By default all the color names of the CSS palette can be chosen, e.g., aqua, orange, gold, goldenrod, etc. To see a full list of supported colors do

colornames_view

The following function have been included to handle colors more efficiently

Improved Import Wizard

Importing EBSD data using the import wizard allows to interactively realign the data and check with respect to the pole figures.

Speed Improvements

Support for hexagonal EBSD grids

The function gridify now works also for EBSD data measured on a hexagonal grid. As a consequence denoising and GND computation for those data is also on the way.

Plastic Deformations

MTEX 5.2. introduces a bunch of new tensor classes to make modelling of plastic deformations more straight forward.

The relationships between those tensors are explained in the section plastic deformations.

Spherical Bingham Distribution

Native support for spherical Bingham distributions, including the ability to fit them to directional distributions.

Tensors

Improved Figure Layout

Misc Changes

ebsd{id}
grains{id}

scatter(v,'numbered')               % plot vectors with numbers
scatter(v,'MarkerFaceColor','none') % plot vectors with colored empty marks

MTEX 5.1.0 04/2018

Dislocation systems

Starting with version 5.1 MTEX introduces a class representing dislocation systems. Dislocation systems may be lists of edge or screw dislocations and are either defined by its burgers and line vectors

cs = crystalSymmetry('432')
b = Miller(1,1,0,cs,'uvw')
l = Miller(1,-1,-2,cs,'uvw')
dS = dislocationSystem(b,l)

by a family of slipsystems

sS = slipSystem.fcc(cs)
dS = dislocationSystem(sS)

or as the family of predefined dominant dislocation systems by

dS = dislocationSystem.fcc(cs)

More information how to calculate with dislocation systems can be found here.

Geometrically necessary dislocations

The newly introduced dislocation systems play an important role when computing geometrically necessary dislocations from EBSD data. The workflow is illustrate the script GND and consists of the following steps:

Tensor arithmetics

dyad, trace, det, mean, diag, eye, sym

Birefringence

MTEX 5.1 includes some basic methods to analyze and simulate optically isotropic materials. This includes the computation of the optical axis, birefringence and spectral transmission. The new features are demonstrated in BirefringenceDemo.

Color Keys

In MTEX 5.1 the color keys used for coloring EBSD have been a bit reorganised.

Spherical functions

Misc

MTEX 5.0.0 03/2018

Replace all executables by two mex files

In MTEX many functionalities are based on the non equispaced fast Fourier transform (NFFT). Until now this dependency was kept under the hood, or more precisely, hidden in external executable files which often caused troubles on MAC systems. Starting with MTEX 5.0. all the executables have been replaced by two mex files provided by the NFFT package. This change (hopefully) comes with the following advantages

Spherical functions

Many functions in MTEX compute directional dependent properties, e.g. pole figures, inverse pole figures, wave velocities, density distribution of misorientation axis or boundary normals. Until now those functions took as an input an of vector of directions and gave as an output a corresponding vector of function values, e.g. the command

pfi = calcPDF(odf,Miller(1,0,0,odf.CS),r)

returns for a list of specimen directions r the corresponding list of pole figure intensities pfi for the ODF odf. Starting with MTEX 5.0 it is possible to omit the list of specimen directions r or replace it by an empty list []. In this case the command

pdf = calcPDF(odf,Miller(1,0,0,odf.CS))

returns a spherical function pdf also called pole density function. One can evaluate this spherical function using the command eval at the list of specimen directions r to obtain the pole figure intensities

pfi = pdf.eval(r)

However, there are many more operations that can be performed on spherical functions:

% compute with spherical functions as with ordinary numbers
pdf3 = 5 * pdf1 + 3 * pdf2
pdf = max(pdf,0) % replace of negative entries by 0
pdf = abs(pdf) % take the absolute value
sum(pdf) % the integral of the pole figure
sum(pdf.^2) % the integral of the pole figure squares - also called pole figure index

% plotting
plot(pdf)
plot3(pdf) % plot in 3d

% detect maximum value
[value,pos] = max(pdf)

% compute the eigen values and eigen vectors
[e,v] = eig(pdf)

For a complete list of functions read here.

Symmetry aware spherical functions

Since most of the directional dependent properties obey additional symmetry properties the class S2FunHarmonic has been extended to respect symmetry in the class S2FunHarmonicSym.

Multivariate spherical functions, vector fields and spherical axis fields

In some cases it is useful that a spherical function gives not only one value for a certain direction but several values. This is equivalent to have concatenate several univariate spherical function to one multivariate function. This can be accomplished by

S2Fmulti = [S2F1,S2F2,S2F3]

which gives a spherical function with 3 values per direction. More information how to work multivariate functions can be found here.

If we interpret the 3 values of S2Fmulti as \(x\), \(y\), and, \(z\) coordinate of a 3 dimensional vector, the function S2Fmulti can essentially be seen as a spherical vector field associating to each direction a three dimensional vector. The most important example of such a vector field is the gradient of a spherical function:

g = S2F1.grad

The resulting variable g is of type S2VectorField. A complete list of functions available for vector fields can be found here.

Another example for vector fields are polarisation directions pp, ps1, ps2 as computed by

[vp,vs1,vs2,pp,ps1,ps2] = velocity(C)

The main difference is, that polarisation directions are antipodal, i.e. one can not distinguish between the polarisation direction d and -d. In MTEX we call vector fields with antipodal values are represented by variables of type AxisField.

Scalar tensor properties are returned as spherical functions

Any scalar or vectorial property of a tensor is not returned as a spherical function or spherical vector field. Examples are the velocity properties mentioned above, Youngs modulus, shear modulus, Poisson ration etc. In particular, plotting those directional dependent quantities is as simple as

plot(C.YoungsModulus)

This makes the old syntax

plot(C,'plotType','YoungsModulus')

obsolete. It is not supported anymore.

Crystal shapes

MTEX 5.0 introduces a new class crystalShape. This class allows to plot 3-dimensional representations of crystals on top of EBSD maps, pole figures and ODF sections. The syntax is as follows

% define the crystal symmetry
cs = loadCIF('quartz');

% define the faces of the crystal
m = Miller({1,0,-1,0},cs);  % hexagonal prism
r = Miller({1,0,-1,1},cs);  % positive rhomboedron, usually bigger then z
z = Miller({0,1,-1,1},cs);  % negative rhomboedron
s2 = Miller({1,1,-2,1},cs); % right tridiagonal bipyramid
x2 = Miller({5,1,-6,1},cs); % right positive Trapezohedron
N = [m,r,z,s2,x2];

% define the crystal shape
habitus = 1.2; % determines the overall shape
extension = [1,1.2,1]; % determines the extension of the crystal in x,y,z direction
cS = crystalShape(N,habitus,extension);

plot(cS)
plot(x,y,cS)
plot(grains,cS)
plot(ebsd,cS)
plotPDF(ori,ori*cS)

ODF component analysis

MTEX 5.0 allows for decomposing ODF into components using the command calcComponents. In its simplest form

[mods,weights] = calcComponents(odf)

returns a list of modal orientations mods and a list of weights which sum up to one. A more advanced call is

[modes, weights,centerId] = calcComponents(odf,'seed',oriList)

which returns in centerId also for each orientation from oriList to which component it belongs.

Clustering of orientations

The ODF component analysis is used as the new default algorithm in calcCluster for orientations. The idea is to compute an ODF out of the orientations and call calcComponents with

[center,~,centerId] = calcComponents(odf,'seed',ori)

Then center are the clusters center and centerId gives for each orientation to which cluster it belongs. Substantial in this method is the choice of the kernel halfwidth used for ODF computation. This can be adjusted by

[c,center] = calcCluster(ori,'halfwidth',2.5*degree)

New tensor classes

With MTEX 5.0 we start introducing specific tensor classes. So far we included the following classes

more tensors are supposed to be included in the future. The central advantage is that tensor specific behaviour and functions can now better be implemented and documented, e.g., that the inverse of the compliance tensor is the stiffness tensor and vice versa. For user the important change is that e.g. the stiffness tensor is now defined by

C = stiffnessTensor(M,cs)

instead of the depreciated syntax

C = tensor(M,cs,'name','elastic stiffness','unit','GPA')

Improved spherical plotting

In MTEX 4.X it was not possible to display the upper and lower hemisphere in pole figure plots, inverse pole figure plots or ODF section plots. This was a server restriction as for certain symmetries both hemispheres do not have to coincide. In MTEX 5.0 this restriction has been overcome. MTEX automatically detects whether the upper and lower hemisphere are symmetrically equivalent and decides whether both hemispheres needs to be plotted. As in the previous version of MTEX this can be controlled by the options upper, lower and complete.

As a consequence the behaviour of MTEX figures have changed slightly. By default MTEX now always plots into the last axis. In order to annotate orientations or directions to all axes in a figure use the new option add2all.

plotIPDF(SantaFe,[xvector,yvector+zvector])
[~,ori] = max(SantaFe)
plot(ori,'add2all')

We also introduced two new functions plotSection and quiverSection to visualize spherical functions restricted to a plane. As an example one can now plot the slowness surfaces of wave velocities in the plane perpendicular to Y with

plotSection(1./vp,vector3d.Y)

see here for more information.

Other new functions

MTEX 4.5.2 11/2017

This is mainly a bug fix release

orientation relation ships

gT = GreningerTrojano(csAlpha,csGamma)
ori_children = ori_parent * inv(gT.variants)
ori_parents = ori_child * gT.parents

MTEX 4.5.1 08/2017

This is mainly a bug fix release

MTEX 4.5 03/2017

3d orientation plots

MTEX 4.5 supports plotting of orientations, fibres, and ODFs in 3d in various projections like

Misorientations

orientation.Bain(cs)
orientation.KurdjumovSachs(cs)
orientation.NishiyamaWassermann(cs)
orientation.Pitch(cs)

Grain Reconstruction

New option to handle non convex other shapes of EBSD data sets

calcGrains(ebsd,'boundary','tight')

Tensors

New functions diag, trace,

EBSD

Rotating, flipping of EBSD data is now done with respect to the center of the map. Previously all these operations where done relatively to the point (0,0). Use

rotate(ebsd,180*degree,'center',[0,0])

to get back the behavior of previous versions.

Colorbar

MTEXColorbar allows now to have a title next to it. Use

mtexColorbar('Title','this is a title')

Bug Fix This release contains several important bug fixes compare to MTEX 4.4.

MTEX 4.4 01/2017

Slip Systems

MTEX 4.4 introduces support for slip systems. Slip systems are defined by a plane normal and a slip direction

sSFCC = slipSystem(Miller(0,1,-1,cs,'uvw'),Miller(1,1,1,cs,'hkl'));

Slip systems are instrumental for computing the following properties

Fibres

MTEX 4.4 adds support for fibres in orientation space. As an example the alpha fibre in cubic materials can be defined in the following ways

cs = crystalSymmetry('m-3m')
f  = fibre.alpha(cs)

f = fibre(Miller(1,0,0,cs),vector3d.X)

ori1 = orientation('Miller',[0 0 1],[1 1 0],cs);
ori2 = orientation('Miller',[1 1 1],[1 1 0],cs);

f = fibre(ori1,ori2)

f = fibre.fit([ori1,ori2,mean(ori1,ori2)])

All commands that took a pair of directions to specify a fibre, e.g., fibreODF, fibreVolume, plotFibre have been rewritten to accept a fibre as a single input argument. I.e. a fibre ODF is now defined by

odf = fibreODF(fibre.alpha(cs))

Up to now the following functions are implemented for fibres

  oR = fundamentalRegion(cs,cs)
  f = fibre(oR.V(1),oR.V(2))
  plot(oR)
  hold on
  plot(fibre,'color','r','linewidth',2)
  hold off

angle(f,ori)

Ignore Symmetry

Many functions support now the flag noSymmetry. Among them are angle, axis, dot, cunion.

Clustering of orientations

The new command calcCluster allows to cluster a given set of orientations into a given number of clusters.

% generate orientation clustered around 5 centers
cs = crystalSymmetry('m-3m');
center = orientation.rand(5,cs);
odf = unimodalODF(center,'halfwidth',5*degree)
ori = odf.calcOrientations(3000);

% find the clusters and its centers
[c,centerRec] = cluster(ori,'numCluster',5);

% visualize result
oR = fundamentalRegion(cs);
plot(oR)

hold on
plot(ori.project2FundamentalRegion,c)
caxis([1,5])
plot(center.project2FundamentalRegion,'MarkerSize',10,'MarkerFaceColor','k','MarkerEdgeColor','k')
plot(centerRec.project2FundamentalRegion,'MarkerSize',10,'MarkerFaceColor','r','MarkerEdgeColor','k')
hold off

MTEX 4.3.2 07/2016

Alignment of Miller plots

You can now specify the alignment of the crystal a-axis or b-axis in Miller plots by

plota2north, plota2east, plota2south, plota2west
plotb2north, plotb2east, plotb2south, plotb2west

This might also be specify in mtex_settings.m mtex_settings.

MTEX 4.3 - 03/2016

Alignment of Miller plots

Starting with MTEX 4.3 plots with respect to the crystal coordinate system, i.e., inverse pole figure plots, misorientation axis plot, ipf keys, are always aligned such that the b-axis points towards east. This follows the convention given in the International Table of Crystallography. The alignment can be adjusted using the option xAxisAlignment

plot(Miller(1,0,0,cs),'xAxisAlignment',30*degree)

Plotting vector fields at grain centers or grain boundaries

There are three new commands

that allow visualizing directions for EBSD data, grains and at grain boundaries. The input argument dir should be a list of vector3d and may represent e.g. slip directions, polarization direction, etc.

EBSD data in raster format

Until MTEX 4.2 EBSD data have been always considered as a one-dimensional list of data, i.e., the often present structure of a regular grid was completely ignored. Starting with MTEX 4.3 EBSD data can be converted in a regular grid by

ebsd = ebsd.gridify

Missing data are represented as NaN in the regular representation. Gridified EBSD data may be addressed analogously like matrixes, i.e.,

ebsd(100,200)

will give pixel 100 in the y-direction and 200 in the x-direction. Analogously.

ebsd(50:100,:)

will give the stripe if pixels with y coordinate between 50 and 100.

Orientation gradients and GND

Gridified EBSD data allows also to compute orientation gradients by

ebsd.gradientX
ebsd.gradientY

as well as an estimate of the geometrically necessary dislocation density (GND) using the command calcGND

ebsd.calcGND

Auxiliary new functionality

MTEX 4.2 - 11/2015

MTEX 4.2 introduces basic functionality for triple junction analysis in grain maps.

Triple points

Triple points are automatically computed during grain reconstruction and can be accessed by

grains.triplePoints
grains.boundary.triplePoints

More details on how to work with triple points can be found here.

large EBSD data sets

Analyzing large EBSD data sets may be quite annoying due to memory consumption and slow plotting. As a work around MTEX includes a new function reduce which allows reducing the data set to each n-th pixel, i.e.,

ebsd_small = reduce(ebsd,2)

contains only 25 percent of the data of the original data set. This functionality is assumed to be used for experimenting around with the data set and setting up a proper analysis script. The final analysis should, if possible, be done with the entire data set.

New option to ignore symmetry

When computing the angle between crystal directions, the misorientation angle between orientations and the misorientation axis symmetry can be ignored with the flag noSymmetry

angle(Miller(1,0,0,cs),Miller(0,1,0,cs),'noSymmetry')
angle(mori,'noSymmetry')
axis(mori,'noSymmetry')

Axis distributions in specimen coordinates

In order to plot axis distributions in specimen coordinates, you can now do

[ori1,ori2] = calcMisorientation(ebsd('phaseName'))
plotAxisDistribution(ori1,ori2,'contourf')

or

ori = ebsd(grains.boundary('indexed').ebsdId).orientations
plotAxisDistribution(ori(:,1),ori(:,2),'contourf')

New option to work around Matlab opengl bug

In mtex_settings.m mtex_settings there is a new option that may help to work around the Matlab opengl bug. Switching it of may give nicer graphics.

setMTEXpref('openglBug',true)

CSL misorientations

The function CSL requires now as a mandatory argument the crystal symmetry of the phase, i.e.

CSL(3,crystalSymmetry('m-3m'))

Grain boundaries

Grain boundaries segments have a new option midPoint which may be used for attaching a vector displaying the misorientation axis or some other direction.

More ODF sections

Along with the old syntax, there is now a new syntax that allows for more fine control of the ODF sections.

oS = phi2Sections(odf.CS,odf.SS)
oS.phi2 = [ 10*degree, 30*degree, 90*degree ];

plot(odf,oS)

Ordering of crystal symmetries

One can now check whether a crystal symmetry cs1 is a subgroup of crystal symmetry cs2 by

cs1 <= cs2

Further, the largest proper subgroup of some crystal symmetry cs is now accessible by

cs.properSubGroup

MTEX 4.1 - 09/2015

MTEX 4.1 introduces new possibilities to the analysis of misorientations. For the first time, it covers all geometric aspects of misorientations between arbitrary crystal symmetries. Furthermore, MTEX 4.1 introduces filters to smooth EBSD data.

Smoothing of EBSD Data

Smoothing of EBSD data might be necessary if the orientation data are corrupted by noise which influences the estimation of orientation dependent properties like KAM or GND. The general syntax for smoothing EBSD data is

ebsd = smooth(ebsd)

This applies the spline filter to the orientation data. Beside the spline filter, many other filters are available. A general discussion on this topic can be found here. To make use of a different than the default filter use the syntax

F = medianFilter
F.numNeighbours = 2 % this way options for the filter can be set
ebsd = smooth(ebsd,F)

The command smooth can also be used to fill not indexed measurement points. This behavior is enabled by the option fill

ebsd = smooth(ebsd,F,'fill')

Support for antipodal symmetry for misorientations

When working with boundary misorientations between the same phase one can not distinguish between a misorientation mori and its inverse |inv(mori). Starting with MTEX 4.1 this symmetry is supported for misorientations and misorientation distribution functions.

mori = inv(ori1) * ori2;
mori.antipodal = true;

mdf = calcMDF(odf1,odf2,'antipodal')

Antipodal symmetry effects the asymmetric region in orientation space as described below, as well as the distance between misorientations. Boundary misorientations between the same phase have set the flag antipodal by default.

Asymmetric regions in orientation space

MTEX 4.1 has now full support of asymmetric regions in orientation space. For any combination of crystal symmetries they can be defined by

oR = fundamentalRegion(cs1,cs2)

and visualized by

plot(oR)

One can check, whether an orientation is within the fundamental region by

oR.checkInside(ori)

similarly as for a sphericalRegion. The fundamental region with antipodal symmetry is defined by.

oR = fundamentalRegion(cs1,cs2,'antipodal')

For a fixed rotational angle omega, the intersection of the fundamental region with the sphere with radius omega gives the fundamental sector for the corresponding rotational axes. The axis sector can be computed by

sR = oR.axisSector(omega)

Axis and angle distributions

Thanks to the implementation of the asymmetric region plotAxisDistribution and plotAngleDistribution works in MTEX 4.1 for any combination of crystal symmetries.

The following syntax is obsolete

plotAxisDistribution(grains.boundary('phase1','phase2'))
plotAngleDistribution(grains.boundary('phase1','phase2'))
plotAngleDistribution(ebsd)

As replacement use the more verbose syntax

plotAxisDistribution(grains.boundary('phase1','phase2').misorientation)
plotAngleDistribution(grains.boundary('phase1','phase2').misorientation)

mori = calcMisorientation(ebsd('phase1'),ebsd('phase2'))
plotAngleDistribution(mori)
plotAxisDistribution(mori)

Rotational axis in specimen coordinates

It is now possible to compute the misorientation axis between two orientations in specimen coordinate system. This is done by

axis(ori1,ori2)

To do so with random misorientations from an EBSD data set do

[ori1,ori2] = calcMisorientation(ebsd('phase1'),ebsd('phase2'))
plot(axis(ori1,ori2))

Axis angle plots

(Mis)Orientation, ODFs, and MDFs can now be plotted in axis angles sections. Those plots respect the fundamental sector depending on the misorientation angle and for all combinations of crystal symmetries. The angle sections are scaled such that they represent the corresponding volume in orientation space. This can be switch off as described below

plotSection(mori,'axisAngle',55*degree)
plotSection(mdf,'axisAngle',(15:10:55)*degree)
plotSection(mdf,'axisAngle',(15:10:55)*degree,'volumeScaling',false)
plotSection(mdf,'axisAngle',(15:10:55)*degree,'antipodal')

Replace plotODF by a plotSection

In most cases, you can replace plotODF by a|plot|. Only for misorientations, the default plot is scattered.

More default settings for EBSD maps and pole figure plots

setMTEXpref('showMicronBar','off')

setMTEXpref('showCoordinates','off')

pfAnnotations = @(varargin) text([vector3d.X,vector3d.Y],{'RD','ND'},...
 'BackgroundColor','w','tag','axesLabels',varargin{:});
setMTEXpref('pfAnnotations',pfAnnotations);

Other improvements since MTEX 4.0.0

During the minor revisions of MTEX also several minor improvements have been added which are summarized below

hostGrain.checkInside(grainList)

plot(odf,pf.h,'superposition',pf.c)

[~,mP] = plot(ebsd)
mP.micronBar.visible = 'off'

plot(xvector,'label','RD','textAboveMarker')

a = axis(o1,o2)  % misorientation axis with respect to sample coordinate system

a = axis(inv(o2)*o1)  % misorientation axis with respect to crystal coordinate system

[x,y] = grains.boundary.intersect(xy1,xy2);

plotAngleDsitribution(mori,'percent')

plot(pf,'minmax')

ebsd_prof = ebsd.spatialProfile(ebsd,some_line)

h = Miller({1,0,0},{1,1,1},{2,3,4},CS,'uvw')

gB.segmentLength % length of the corresponding connected segment
gB.isTwinning(mori,threshold) % check boundary for twinning

cs.Aaxis
cs.AaxisRec

MTEX 4.0.0 - 10/2014

MTEX 4 is a complete rewrite of the internal class system which was required to keep MTEX compatible with upcoming Matlab releases. Note that MTEX 3.5 will not work on Matlab versions later than 2014a. As a positive side effect, the syntax has been made more consistent and powerful. On the bad side MTEX 3.5. code will need some adaption to run on MTEX 4. There are two general principles to consider

Use dot indexing instead of getting and setting methods

The syntax

h = get(m,'h')
m = set(m,'h',h+1)

is obsolete. set and get methods are not longer supported by any MTEX class. Instead use dot indexing

h = m.h
m.h = h + 1

Note, that this syntax can be nested, i.e., one can write

ebsd('Forsterite').orientations.angle

to get the rotational angle of all Forsterite orientations, or,

cs.axes(1).x

to get the x coordinate of the first crystallographic coordinate axis - the a-axis. As a nice bonus, you can now use TAB completion to cycle through all possible properties and methods of a class.

Use camelCaseCommands instead of under_score_commands

Formerly, MTEX used different naming conventions for functions. Starting with MTEX 4.0 all function names consisting of several words, have the first word spelled with lowercase letters and the consecutive words starting with a capital letter. Most notable changes are * |plotPDF| * |plotIPDF| * |plotODF| * |calcError|

Grain boundaries are now directly accessible

MTEX 4.0 introduces a new type of variables called grainBoundary which allows to represent arbitrary grain boundaries and to work with them as with grains. The following lines give some examples. Much more is possible.

% select boundary from specific grains
grains.boundary

% select boundary by phase transition
gB = grains.boundary('Forsterite','Enstatite')

% select boundary by misorientation angle
gB(gB.misorientation.angle>100*degree)

% compute misorientation angle distribution for specific grain boundaries
plotAngleDistribution(gB)

Plotting EBSD, grain, grainBoundary data has different syntax

The syntax of the plot commands has made more consistent throughout MTEX. It is now

plot(obj,data)

where obj is the object to be plotted, i.e., EBSD data, grains, grain boundaries, spherical vectors, pole figures, etc., and the data are either pure numbers or RGB values describing the color. Examples are

% plot MAD values of EBSD data
plot(ebsd,ebsd.mad)

% colorize grains according to area
plot(grains,grains.area)

% colorize grain boundary according to misorientation angle
gB = grains.boundary('Forsterite','Enstatite')
plot(gB,gB.misorientation.angle)

Colorization according to phase or phase transition is the new default when calling plot without data argument, i.e., the following results in a phase plot

plot(ebsd)

In order to colorize ebsd data according to orientations, one has first to define an orientationMapping by

oM = ipdfHSVOrientationMapping(ebsd('Forsterite'))

Then one can use the command oM.orientation2color to compute RGB values for the orientations

plot(ebsd('Forsterite'),oM.orientation2color(ebsd('Forsterite').orientations))

The orientation mapping can be visualized by

plot(oM)

EBSD data are always spatially indexed

Starting with MTEX 4.0 EBSD data always have to have x and y coordinates. EBSD data without spatial coordinates are imported simply as orientations. As a consequence, all orientation related functionalities of EBSD data have been moved to orientations, i.e., you can not do anymore

plotpdf(ebsd('Fo'),Miller(1,0,0,CS))
calcODF(ebsd('Fo'))
volume((ebsd('Fo'))

But instead you have to explicitly state that you operate on the orientations, i.e.

plotpdf(ebsd('Fo').orientations,Miller(1,0,0,ebsd('Fo').CS))
calcODF(ebsd('Fo').orientations)
volume((ebsd('Fo').orientations)

This makes it more easy to apply the same functions to misorientations to grain mean orientations grains.meanOrientation, ebsd misorientation to mean mean |ebsd.mis2mean or boundary misorientations grains.boundary.misorientation

Different syntax for reconstructing grains from EBSD data

In MTEX 3.5 the command

grains = calcGrains(ebsd)

duplicates the ebsd data into the grain variable allowing to access the EBSD data belonging to a specific grain by

get(grains(1),'EBSD')

In MTEX 4.0 the command calcGrains returns as an additional output the list of grainIds that is associated with the EBSD data. When storing these grainIds directly inside the EBSD data, i.e., by

[grains,ebsd.grainId] calcGrains(ebsd)

one can access the EBSD data belonging to a specific grain by the command

ebsd(grains(1))

MTEX 4.0 distinguishes between crystal and specimen symmetry

In MTEX 4.0 two new variable types specimenSymmetry and crystalSymmetry have been introduced to distinguish clearly between these two types of symmetry. Calling

cs = symmetry('m-3m')
ss = symmetry('triclinic')

is not allowed anymore! Please use instead

cs = crystalSymmetry('m-3m','mineral','phaseName')
ss = specimenSymmetry('triclinic')

Pole figure indexing is now analogously to EBSD data

You can now index pole figure data by conditions in the same manner as EBSD data. E.g. the condition

condition = pf.r.theta < 80 * degree

is an index to all pole figure data with a polar angle smaller than 80 degree. To restrict the pole figure variable pf to the data write

pf_restricted = pf(condition)

In the same manner, we can also remove all negative intensities

condition = pf.intensities < 0
pf(condition) = []

In order to address individual pole figures within a array of pole figures pf use the syntax

pf('111')

or

pf(Miller(1,1,1,cs))

The old syntax

pf(1)

for accessing the first pole figure will not work anymore as it now refers to the first pole figure measurement. The direct replacement for the above command is

pf({1})

MTEX 4.0 supports all 32 point groups

In MTEX 4.0 it is for the first time possible to calculate with reflections and inversions. As a consequence, all 32 point groups are supported. This is particularly important when working with piezoelectric tensors and symmetries like 4mm. Moreover, MTEX distinguishes between the point groups 112, 121, 112 up to -3m1 and -31m.

Care should be taken, when using non-Laue groups for pole figure or EBSD data.

Support for three-digit notation for Miller indices of trigonal symmetries

MTEX 4.0 understands now uvw and UVTW notation for trigonal symmetries. The following two commands define the same crystallographic direction, namely the a1-axis

Miller(1,0,0,crystalSymmetry('-3m'),'uvw')

Miller(2,-1,-1,0,crystalSymmetry('-3m'),'UVTW')

Improved graphics

MTEX can now display colorbars next to pole figure, tensor or ODF plots and offers much more powerful options to customize the plots with titles, legends, etc.

Functionality that has been (temporarily) removed

This can be seen as a todo list.

MTEX 3.5.0 - 12/2013

Misorientation colorcoding

plotBoundary(grains('Fo'),'property','misorientation','colorcoding','patala')

Fast multiscale clustering (FMC) method for grain reconstruction

grains = calcGrains(ebsd,'FMC')

Misc changes

get(grains,'id')

poly = [ [x1,y1];[x2,y2];[xn,yn];[x1,y1] ]
grains = calcGrains(ebsd,'boundary',poly)

poly = selectPolygon

Bug fixes

MTEX 3.4.2 - 06/2013

bugfix release

MTEX 3.4.1 - 04/2013

bugfix release

MTEX 3.4.0 - 03/2013

New plotting engine

MTEX 3.4 features a completely rewritten plotting engine. New features include

plotzOutOfPlane, plotzIntoPlane

ax = subplot(2,2,1)
plot(ax,xvector)

plotpdf(ebsd,Miller(1,0,0),'contourf')

Colormap handling

mtexColorMap red2blue

ODF

[modes, values] = calcModes(odf,n)

EBSD data

% convert spatial coordinates to Euler angle coordinate system
loadEBSD('filename','convertSpatial2EulerReferenceFrame')

% convert Euler angles to spatial coordinate system
loadEBSD('filename','convertEuler2SpatialReferenceFrame')

CS = symmetry('cubic','mineral','Mg','color','red')

inpolygon(ebsd,[xmin ymin xmax ymax])

Tensors

R = SchmidTensor(m,n)

[tauMax,mActive,nActive,tau,ind] = calcShearStress(stressTensor,m,n,'symmetrise')

% extract entry 1,1,1,1 in tensor notation
C{1,1,1,1}

% extract entry 1,1 in Voigt notation
C{1,1}

% extract the first tensor
C(1)

Import / Export

export(ori,'fname')

v = loadVector3d('fname','ColumnNames',{'x','y','z'})
v = loadVector3d('fname','ColumnNames',{'latitude','longitude'})

General

setpref('mtex','propertyName','propertyValue')

has been replaced by

setMTEXpref('propertyName','propertyValue')

MTEX 3.3.2 - 01/2013

bugfix release

MTEX 3.3.1 - 07/2012

bugfix release

MTEX 3.3.0 - 06/2012

Grains: change of internal representation

Reimplementation of the whole grain part:

get(grains,'EBSD')

EBSD

The behavior of the 'ignorePhase' changed. Now it is called in general 'not indexed' and the not indexed data is imported generally. If the crystal symmetry of an EBSD phase is set to a string value, it will be treated as not indexed. e.g. mark the first phase as 'not indexed'

CS = {'not indexed',...
      symmetry('cubic','mineral','Fe'),...
      symmetry('cubic','mineral','Mg')};

By default, calcGrains does also use the 'not Indexed' phase.

Other

MTEX 3.2.3 - 03/2012

bugfix release

MTEX 3.2.1 - 11/2011

New Features

Bug Fixes

MTEX 3.2 - 05/2011

3d EBSD Analysis

This release for the first time supports 3d EBSD data. In particular, MTEX is now able to

Misorientation Analysis

New Syntax for EBSD and grain variables

EBSD and grain variables can now be indexed by phase, region or grain / ebsd variables. Let us assume we have a two phase ebsd variable containing 'Fe' and 'Mg' then can restrict our dataset to the Fe - phase only by writing

ebsd('Fe')

The same works with grains and also with more than one phase. Please have a look into the documentation for information how to index ebsd and grain variables.

Accordingly the following syntax is now depreciated.

calcODF(ebsd,'phase',2)

It should be replaced by

calcODF(ebsd('Fe'))

Other Enhancements

MTEX 3.1 - 03/2011

Tensor Arithmetics This release introduces tensor analysis into MTEX, this includes

Other Enhancements

MTEX 3.0 - 10/2010

Crystal Geometry

This release contains a completely redesigned crystal geometry engine which is thought to be much more intuitive and flexible. In particular, it introduces two new classes rotation and orientation which make it much easier to work with crystal orientations. Resulting features are

Other Enhancements

MTEX 2.0 - 10/2009

Grain Analysis for EBSD Data

MTEX is now able to partition spatial EBSD data into grains. This allows for the computation of various grain characteristics, as well as the computation and visualization of the grain boundaries and neighborhood relationships. Main features are:

Visualization Improvements

General Improvements

Incompatible Changes to Previous Versions

MTEX 1.2 - 05/2009

Improved EBSD import

Improved EBSD plotting

General Improvements

Incompatible Changes to Previous Versions

MTEX 1.1 - 12/2008

Improved Import Wizard

Improved Pole Figure Analysis

Improved EBSD Data Support

Improved Plotting

Bug Fixes

MTEX 1.0 - 06/2008

New Installer Including Binaries for Windows, Linux, and Max OSX

New ODF Class

New Interfaces

Improved Plotting

Incompatible Changes With Previous Releases

Improved Documentation

MTEX comes now with over 500 help pages explaining the mathematical concepts, the philosophy behind MTEX and the syntax and usage of all 300 functions available in MTEX. Furthermore, you find numerous examples and tutorials on ODF estimation, data import, calculation of texture characteristics, ODF and pole figure plotting, etc.

Bug Fixes

MTEX 0.4 - 04/2008

Speed Improvements

New Support of EBSD Data Analysis

New Functions

Incompatible Changes With Previous Releases

MTEX 0.3 - 10/2007

MTEX 0.2 - 07/2007

MTEX 0.1 - 03/2007