<divid="unreleased-message"> You are reading an old version of the documentation (v3.2.2). For the latest version see <ahref="https://matplotlib.org/stable/api/tri_api.html">https://matplotlib.org/stable/api/tri_api.html</a></div>
<spanid="matplotlib-tri"></span><h1><codeclass="docutils literal notranslate"><spanclass="pre">matplotlib.tri</span></code><aclass="headerlink" href="#module-matplotlib.tri" title="Permalink to this headline">¶</a></h1>
<p>Unstructured triangular grid functions.</p>
<dlclass="py class">
<dtid="matplotlib.tri.Triangulation">
<emclass="property">class </em><codeclass="descclassname">matplotlib.tri.</code><codeclass="descname">Triangulation</code><spanclass="sig-paren">(</span><em><spanclass="n">x</span></em>, <em><spanclass="n">y</span></em>, <em><spanclass="n">triangles</span><spanclass="o">=</span><spanclass="default_value">None</span></em>, <em><spanclass="n">mask</span><spanclass="o">=</span><spanclass="default_value">None</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/triangulation.html#Triangulation"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.Triangulation" title="Permalink to this definition">¶</a></dt>
<dd><p>An unstructured triangular grid consisting of npoints points and
ntri triangles. The triangles can either be specified by the user
or automatically generated using a Delaunay triangulation.</p>
<trclass="field-odd field"><thclass="field-name">Parameters:</th><tdclass="field-body"><dlclass="first last docutils">
<dt><strong>x, y</strong><spanclass="classifier">array-like of shape (npoints)</span></dt><dd><p>Coordinates of grid points.</p>
</dd>
<dt><strong>triangles</strong><spanclass="classifier">integer array-like of shape (ntri, 3), optional</span></dt><dd><p>For each triangle, the indices of the three points that make
up the triangle, ordered in an anticlockwise manner. If not
specified, the Delaunay triangulation is calculated.</p>
</dd>
<dt><strong>mask</strong><spanclass="classifier">boolean array-like of shape (ntri), optional</span></dt><dd><p>Which triangles are masked out.</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
<pclass="rubric">Notes</p>
<p>For a Triangulation to be valid it must not have duplicate points,
triangles formed from colinear points, or overlapping triangles.</p>
<codeclass="descname">calculate_plane_coefficients</code><spanclass="sig-paren">(</span><em><spanclass="n">self</span></em>, <em><spanclass="n">z</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/triangulation.html#Triangulation.calculate_plane_coefficients"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.Triangulation.calculate_plane_coefficients" title="Permalink to this definition">¶</a></dt>
<dd><p>Calculate plane equation coefficients for all unmasked triangles from
the point (x, y) coordinates and specified z-array of shape (npoints).
The returned array has shape (npoints, 3) and allows z-value at (x, y)
<emclass="property">property </em><codeclass="descname">edges</code><aclass="headerlink" href="#matplotlib.tri.Triangulation.edges" title="Permalink to this definition">¶</a></dt>
<dd><p>Return integer array of shape (nedges, 2) containing all edges of
non-masked triangles.</p>
<p>Each row defines an edge by it's start point index and end point
index. Each edge appears only once, i.e. for an edge between points
<em>i</em> and <em>j</em>, there will only be either <em>(i, j)</em> or <em>(j, i)</em>.</p>
<codeclass="descname">get_cpp_triangulation</code><spanclass="sig-paren">(</span><em><spanclass="n">self</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/triangulation.html#Triangulation.get_cpp_triangulation"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.Triangulation.get_cpp_triangulation" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the underlying C++ Triangulation object, creating it
<emclass="property">static </em><codeclass="descname">get_from_args_and_kwargs</code><spanclass="sig-paren">(</span><em><spanclass="o">*</span><spanclass="n">args</span></em>, <em><spanclass="o">**</span><spanclass="n">kwargs</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/triangulation.html#Triangulation.get_from_args_and_kwargs"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.Triangulation.get_from_args_and_kwargs" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a Triangulation object from the args and kwargs, and
the remaining args and kwargs with the consumed values removed.</p>
<p>There are two alternatives: either the first argument is a
Triangulation object, in which case it is returned, or the args
and kwargs are sufficient to create a new Triangulation to
return. In the latter case, see Triangulation.__init__ for
<codeclass="descname">get_masked_triangles</code><spanclass="sig-paren">(</span><em><spanclass="n">self</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/triangulation.html#Triangulation.get_masked_triangles"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.Triangulation.get_masked_triangles" title="Permalink to this definition">¶</a></dt>
<dd><p>Return an array of triangles that are not masked.</p>
<codeclass="descname">get_trifinder</code><spanclass="sig-paren">(</span><em><spanclass="n">self</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/triangulation.html#Triangulation.get_trifinder"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.Triangulation.get_trifinder" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the default <aclass="reference internal" href="#matplotlib.tri.TriFinder" title="matplotlib.tri.TriFinder"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">matplotlib.tri.TriFinder</span></code></a> of this
triangulation, creating it if necessary. This allows the same
TriFinder object to be easily shared.</p>
</dd></dl>
<dlclass="py method">
<dtid="matplotlib.tri.Triangulation.neighbors">
<emclass="property">property </em><codeclass="descname">neighbors</code><aclass="headerlink" href="#matplotlib.tri.Triangulation.neighbors" title="Permalink to this definition">¶</a></dt>
<dd><p>Return integer array of shape (ntri, 3) containing neighbor triangles.</p>
<p>For each triangle, the indices of the three triangles that
share the same edges, or -1 if there is no such neighboring
triangle. <codeclass="docutils literal notranslate"><spanclass="pre">neighbors[i,</span><spanclass="pre">j]</span></code> is the triangle that is the neighbor
to the edge from point index <codeclass="docutils literal notranslate"><spanclass="pre">triangles[i,j]</span></code> to point index
<codeclass="descname">set_mask</code><spanclass="sig-paren">(</span><em><spanclass="n">self</span></em>, <em><spanclass="n">mask</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/triangulation.html#Triangulation.set_mask"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.Triangulation.set_mask" title="Permalink to this definition">¶</a></dt>
<dd><p>Set or clear the mask array. This is either None, or a boolean
array of shape (ntri).</p>
</dd></dl>
</dd></dl>
<dlclass="py class">
<dtid="matplotlib.tri.TriFinder">
<emclass="property">class </em><codeclass="descclassname">matplotlib.tri.</code><codeclass="descname">TriFinder</code><spanclass="sig-paren">(</span><em><spanclass="n">triangulation</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/trifinder.html#TriFinder"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.TriFinder" title="Permalink to this definition">¶</a></dt>
<dd><p>Abstract base class for classes used to find the triangles of a
Triangulation in which (x, y) points lie.</p>
<p>Rather than instantiate an object of a class derived from TriFinder, it is
<p>Derived classes implement __call__(x, y) where x and y are array-like point
coordinates of the same shape.</p>
</dd></dl>
<dlclass="py class">
<dtid="matplotlib.tri.TrapezoidMapTriFinder">
<emclass="property">class </em><codeclass="descclassname">matplotlib.tri.</code><codeclass="descname">TrapezoidMapTriFinder</code><spanclass="sig-paren">(</span><em><spanclass="n">triangulation</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/trifinder.html#TrapezoidMapTriFinder"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.TrapezoidMapTriFinder" title="Permalink to this definition">¶</a></dt>
<p><aclass="reference internal" href="#matplotlib.tri.TriFinder" title="matplotlib.tri.TriFinder"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">TriFinder</span></code></a> class implemented using the trapezoid
map algorithm from the book "Computational Geometry, Algorithms and
Applications", second edition, by M. de Berg, M. van Kreveld, M. Overmars
and O. Schwarzkopf.</p>
<p>The triangulation must be valid, i.e. it must not have duplicate points,
triangles formed from colinear points, or overlapping triangles. The
algorithm has some tolerance to triangles formed from colinear points, but
this should not be relied upon.</p>
</dd></dl>
<dlclass="py class">
<dtid="matplotlib.tri.TriInterpolator">
<emclass="property">class </em><codeclass="descclassname">matplotlib.tri.</code><codeclass="descname">TriInterpolator</code><spanclass="sig-paren">(</span><em><spanclass="n">triangulation</span></em>, <em><spanclass="n">z</span></em>, <em><spanclass="n">trifinder</span><spanclass="o">=</span><spanclass="default_value">None</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/triinterpolate.html#TriInterpolator"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.TriInterpolator" title="Permalink to this definition">¶</a></dt>
<dd><p>Abstract base class for classes used to perform interpolation on
triangular grids.</p>
<p>Derived classes implement the following methods:</p>
<dt><strong>z</strong><spanclass="classifier">array-like of shape (npoints,)</span></dt><dd><p>Array of values, defined at grid points, to interpolate between.</p>
</dd>
<dt><strong>trifinder</strong><spanclass="classifier"><aclass="reference internal" href="#matplotlib.tri.TriFinder" title="matplotlib.tri.TriFinder"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">TriFinder</span></code></a> object, optional</span></dt><dd><p>If this is not specified, the Triangulation's default TriFinder will
<codeclass="descname">gradient</code><spanclass="sig-paren">(</span><em><spanclass="n">self</span></em>, <em><spanclass="n">x</span></em>, <em><spanclass="n">y</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/triinterpolate.html#LinearTriInterpolator.gradient"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.LinearTriInterpolator.gradient" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a list of 2 masked arrays containing interpolated derivatives
<dt><strong>x, y</strong><spanclass="classifier">array-like</span></dt><dd><p>x and y coordinates of the same shape and any number of
dimensions.</p>
</dd>
</dl>
</td>
</tr>
<trclass="field-even field"><thclass="field-name">Returns:</th><tdclass="field-body"><dlclass="first last docutils">
<dt><strong>dzdx, dzdy</strong><spanclass="classifier">np.ma.array</span></dt><dd><p>2 masked arrays of the same shape as <em>x</em> and <em>y</em>; values
corresponding to (x, y) points outside of the triangulation
are masked out.
The first returned array contains the values of
<spanclass="math notranslate nohighlight">\(\frac{\partial z}{\partial x}\)</span> and the second those of
<dt><strong>z</strong><spanclass="classifier">array-like of shape (npoints,)</span></dt><dd><p>Array of values, defined at grid points, to interpolate between.</p>
</dd>
<dt><strong>kind</strong><spanclass="classifier">{'min_E', 'geom', 'user'}, optional</span></dt><dd><p>Choice of the smoothing algorithm, in order to compute
the interpolant derivatives (defaults to 'min_E'):</p>
<blockquote>
<div><ulclass="simple">
<li>if 'min_E': (default) The derivatives at each node is computed
to minimize a bending energy.</li>
<li>if 'geom': The derivatives at each node is computed as a
weighted average of relevant triangle normals. To be used for
speed optimization (large grids).</li>
<li>if 'user': The user provides the argument <em>dz</em>, no computation
is hence needed.</li>
</ul>
</div></blockquote>
</dd>
<dt><strong>trifinder</strong><spanclass="classifier"><aclass="reference internal" href="#matplotlib.tri.TriFinder" title="matplotlib.tri.TriFinder"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">TriFinder</span></code></a> object, optional</span></dt><dd><p>If not specified, the Triangulation's default TriFinder will
<dt><strong>dz</strong><spanclass="classifier">tuple of array-likes (dzdx, dzdy), optional</span></dt><dd><p>Used only if <em>kind</em> ='user'. In this case <em>dz</em> must be provided as
(dzdx, dzdy) where dzdx, dzdy are arrays of the same shape as <em>z</em> and
are the interpolant first derivatives at the <em>triangulation</em> points.</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
<pclass="rubric">Notes</p>
<p>This note is a bit technical and details the way a
<codeclass="descname">gradient</code><spanclass="sig-paren">(</span><em><spanclass="n">self</span></em>, <em><spanclass="n">x</span></em>, <em><spanclass="n">y</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/triinterpolate.html#CubicTriInterpolator.gradient"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.CubicTriInterpolator.gradient" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a list of 2 masked arrays containing interpolated derivatives
<dt><strong>x, y</strong><spanclass="classifier">array-like</span></dt><dd><p>x and y coordinates of the same shape and any number of
dimensions.</p>
</dd>
</dl>
</td>
</tr>
<trclass="field-even field"><thclass="field-name">Returns:</th><tdclass="field-body"><dlclass="first last docutils">
<dt><strong>dzdx, dzdy</strong><spanclass="classifier">np.ma.array</span></dt><dd><p>2 masked arrays of the same shape as <em>x</em> and <em>y</em>; values
corresponding to (x, y) points outside of the triangulation
are masked out.
The first returned array contains the values of
<spanclass="math notranslate nohighlight">\(\frac{\partial z}{\partial x}\)</span> and the second those of
<emclass="property">class </em><codeclass="descclassname">matplotlib.tri.</code><codeclass="descname">TriRefiner</code><spanclass="sig-paren">(</span><em><spanclass="n">triangulation</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/trirefine.html#TriRefiner"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.TriRefiner" title="Permalink to this definition">¶</a></dt>
<dd><p>Abstract base class for classes implementing mesh refinement.</p>
<p>A TriRefiner encapsulates a Triangulation object and provides tools for
mesh refinement and interpolation.</p>
<p>Derived classes must implements:</p>
<blockquote>
<div><ul>
<li><pclass="first"><codeclass="docutils literal notranslate"><spanclass="pre">refine_triangulation(return_tri_index=False,</span><spanclass="pre">**kwargs)</span></code> , where
the optional keyword arguments <em>kwargs</em> are defined in each
TriRefiner concrete implementation, and which returns:</p>
<blockquote>
<div><ulclass="simple">
<li>a refined triangulation</li>
<li>optionally (depending on <em>return_tri_index</em>), for each
point of the refined triangulation: the index of
the initial triangulation triangle to which it belongs.</li>
<li>the other optional keyword arguments <em>kwargs</em> are defined in
each TriRefiner concrete implementation</li>
</ul>
</div></blockquote>
<p>and which returns (as a tuple) a refined triangular mesh and the
interpolated values of the field at the refined triangulation nodes.</p>
</li>
</ul>
</div></blockquote>
</dd></dl>
<dlclass="py class">
<dtid="matplotlib.tri.UniformTriRefiner">
<emclass="property">class </em><codeclass="descclassname">matplotlib.tri.</code><codeclass="descname">UniformTriRefiner</code><spanclass="sig-paren">(</span><em><spanclass="n">triangulation</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/trirefine.html#UniformTriRefiner"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.UniformTriRefiner" title="Permalink to this definition">¶</a></dt>
<dt><strong>z</strong><spanclass="classifier">1d-array-like of length <codeclass="docutils literal notranslate"><spanclass="pre">n_points</span></code></span></dt><dd><p>Values of the field to refine, defined at the nodes of the
encapsulated triangulation. (<codeclass="docutils literal notranslate"><spanclass="pre">n_points</span></code> is the number of points
in the initial triangulation)</p>
</dd>
<dt><strong>triinterpolator</strong><spanclass="classifier"><aclass="reference internal" href="#matplotlib.tri.TriInterpolator" title="matplotlib.tri.TriInterpolator"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">TriInterpolator</span></code></a>, optional</span></dt><dd><p>Interpolator used for field interpolation. If not specified,
a <aclass="reference internal" href="#matplotlib.tri.CubicTriInterpolator" title="matplotlib.tri.CubicTriInterpolator"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">CubicTriInterpolator</span></code></a> will
be used.</p>
</dd>
<dt><strong>subdiv</strong><spanclass="classifier">integer, optional</span></dt><dd><p>Recursion level for the subdivision. Defaults to 3.
Each triangle will be divided into <codeclass="docutils literal notranslate"><spanclass="pre">4**subdiv</span></code> child triangles.</p>
</dd>
</dl>
</td>
</tr>
<trclass="field-even field"><thclass="field-name">Returns:</th><tdclass="field-body"><dlclass="first last docutils">
<dt><strong>refi_z</strong><spanclass="classifier">1d array of length: <em>refi_tri</em> node count.</span></dt><dd><p>The returned interpolated field (at <em>refi_tri</em> nodes)</p>
<codeclass="descname">refine_triangulation</code><spanclass="sig-paren">(</span><em><spanclass="n">self</span></em>, <em><spanclass="n">return_tri_index</span><spanclass="o">=</span><spanclass="default_value">False</span></em>, <em><spanclass="n">subdiv</span><spanclass="o">=</span><spanclass="default_value">3</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/trirefine.html#UniformTriRefiner.refine_triangulation"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.UniformTriRefiner.refine_triangulation" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes an uniformly refined triangulation <em>refi_triangulation</em> of
the encapsulated <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">triangulation</span></code>.</p>
<p>This function refines the encapsulated triangulation by splitting each
father triangle into 4 child sub-triangles built on the edges midside
nodes, recursively (level of recursion <em>subdiv</em>).
In the end, each triangle is hence divided into <codeclass="docutils literal notranslate"><spanclass="pre">4**subdiv</span></code>
child triangles.
The default value for <em>subdiv</em> is 3 resulting in 64 refined
subtriangles for each triangle of the initial triangulation.</p>
<dt><strong>return_tri_index</strong><spanclass="classifier">boolean, optional</span></dt><dd><p>Boolean indicating whether an index table indicating the father
triangle index of each point will be returned. Default value
False.</p>
</dd>
<dt><strong>subdiv</strong><spanclass="classifier">integer, optional</span></dt><dd><p>Recursion level for the subdivision. Defaults value 3.
Each triangle will be divided into <codeclass="docutils literal notranslate"><spanclass="pre">4**subdiv</span></code> child triangles.</p>
</dd>
</dl>
</td>
</tr>
<trclass="field-even field"><thclass="field-name">Returns:</th><tdclass="field-body"><dlclass="first last docutils">
<dt><strong>found_index</strong><spanclass="classifier">array-like of integers</span></dt><dd><p>Index of the initial triangulation containing triangle, for each
point of <em>refi_triangulation</em>.
Returned only if <em>return_tri_index</em> is set to True.</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
</dd></dl>
</dd></dl>
<dlclass="py class">
<dtid="matplotlib.tri.TriAnalyzer">
<emclass="property">class </em><codeclass="descclassname">matplotlib.tri.</code><codeclass="descname">TriAnalyzer</code><spanclass="sig-paren">(</span><em><spanclass="n">triangulation</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/tritools.html#TriAnalyzer"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.TriAnalyzer" title="Permalink to this definition">¶</a></dt>
<dd><p>Define basic tools for triangular mesh analysis and improvement.</p>
<codeclass="descname">circle_ratios</code><spanclass="sig-paren">(</span><em><spanclass="n">self</span></em>, <em><spanclass="n">rescale</span><spanclass="o">=</span><spanclass="default_value">True</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/tritools.html#TriAnalyzer.circle_ratios"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.TriAnalyzer.circle_ratios" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a measure of the triangulation triangles flatness.</p>
<p>The ratio of the incircle radius over the circumcircle radius is a
widely used indicator of a triangle flatness.
It is always <codeclass="docutils literal notranslate"><spanclass="pre"><=</span><spanclass="pre">0.5</span></code> and <codeclass="docutils literal notranslate"><spanclass="pre">==</span><spanclass="pre">0.5</span></code> only for equilateral
triangles. Circle ratios below 0.01 denote very flat triangles.</p>
<p>To avoid unduly low values due to a difference of scale between the 2
axis, the triangular mesh can first be rescaled to fit inside a unit
square with <aclass="reference internal" href="#matplotlib.tri.TriAnalyzer.scale_factors" title="matplotlib.tri.TriAnalyzer.scale_factors"><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">scale_factors</span></code></a> (Only if <em>rescale</em> is True, which is
<dt><strong>rescale</strong><spanclass="classifier">boolean, optional</span></dt><dd><p>If True, a rescaling will be internally performed (based on
<aclass="reference internal" href="#matplotlib.tri.TriAnalyzer.scale_factors" title="matplotlib.tri.TriAnalyzer.scale_factors"><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">scale_factors</span></code></a>, so that the (unmasked) triangles fit
exactly inside a unit square mesh. Default is True.</p>
</dd>
</dl>
</td>
</tr>
<trclass="field-even field"><thclass="field-name">Returns:</th><tdclass="field-body"><dlclass="first last docutils">
<dt><strong>circle_ratios</strong><spanclass="classifier">masked array</span></dt><dd><p>Ratio of the incircle radius over the
circumcircle radius, for each 'rescaled' triangle of the
encapsulated triangulation.
Values corresponding to masked triangles are masked out.</p>
<codeclass="descname">get_flat_tri_mask</code><spanclass="sig-paren">(</span><em><spanclass="n">self</span></em>, <em><spanclass="n">min_circle_ratio</span><spanclass="o">=</span><spanclass="default_value">0.01</span></em>, <em><spanclass="n">rescale</span><spanclass="o">=</span><spanclass="default_value">True</span></em><spanclass="sig-paren">)</span><aclass="reference internal" href="../_modules/matplotlib/tri/tritools.html#TriAnalyzer.get_flat_tri_mask"><spanclass="viewcode-link">[source]</span></a><aclass="headerlink" href="#matplotlib.tri.TriAnalyzer.get_flat_tri_mask" title="Permalink to this definition">¶</a></dt>
<dd><p>Eliminates excessively flat border triangles from the triangulation.</p>
<p>Returns a mask <em>new_mask</em> which allows to clean the encapsulated
triangulation from its border-located flat triangles
(according to their <aclass="reference internal" href="#matplotlib.tri.TriAnalyzer.circle_ratios" title="matplotlib.tri.TriAnalyzer.circle_ratios"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">circle_ratios()</span></code></a>).
This mask is meant to be subsequently applied to the triangulation
using <aclass="reference internal" href="#matplotlib.tri.Triangulation.set_mask" title="matplotlib.tri.Triangulation.set_mask"><codeclass="xref py py-func docutils literal notranslate"><spanclass="pre">matplotlib.tri.Triangulation.set_mask()</span></code></a>.
<em>new_mask</em> is an extension of the initial triangulation mask
in the sense that an initially masked triangle will remain masked.</p>
<p>The <em>new_mask</em> array is computed recursively; at each step flat
triangles are removed only if they share a side with the current mesh
border. Thus no new holes in the triangulated domain will be created.</p>
<dt><strong>min_circle_ratio</strong><spanclass="classifier">float, optional</span></dt><dd><p>Border triangles with incircle/circumcircle radii ratio r/R will
be removed if r/R < <em>min_circle_ratio</em>. Default value: 0.01</p>
</dd>
<dt><strong>rescale</strong><spanclass="classifier">boolean, optional</span></dt><dd><p>If True, a rescaling will first be internally performed (based on
<aclass="reference internal" href="#matplotlib.tri.TriAnalyzer.scale_factors" title="matplotlib.tri.TriAnalyzer.scale_factors"><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">scale_factors</span></code></a> ), so that the (unmasked) triangles fit
exactly inside a unit square mesh. This rescaling accounts for the
difference of scale which might exist between the 2 axis. Default
(and recommended) value is True.</p>
</dd>
</dl>
</td>
</tr>
<trclass="field-even field"><thclass="field-name">Returns:</th><tdclass="field-body"><dlclass="first last docutils">
<dt><strong>new_mask</strong><spanclass="classifier">array-like of booleans</span></dt><dd><p>Mask to apply to encapsulated triangulation.
All the initially masked triangles remain masked in the
<em>new_mask</em>.</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
<pclass="rubric">Notes</p>
<p>The rationale behind this function is that a Delaunay
triangulation - of an unstructured set of points - sometimes contains
almost flat triangles at its border, leading to artifacts in plots
(especially for high-resolution contouring).
Masked with computed <em>new_mask</em>, the encapsulated
triangulation would contain no more unmasked border triangles
with a circle ratio below <em>min_circle_ratio</em>, thus improving the
mesh quality for subsequent plots or interpolation.</p>
</dd></dl>
<dlclass="py method">
<dtid="matplotlib.tri.TriAnalyzer.scale_factors">
<emclass="property">property </em><codeclass="descname">scale_factors</code><aclass="headerlink" href="#matplotlib.tri.TriAnalyzer.scale_factors" title="Permalink to this definition">¶</a></dt>
<dd><p>Factors to rescale the triangulation into a unit square.</p>
<p>Returns <em>k</em>, tuple of 2 scale factors.</p>