import contextlib
import fnmatch
import re
import warnings
from ..tecutil import _tecutil, _tecutil_connector, sv
from ..constant import *
from ..exception import *
from .. import legend, session, tecutil, text, version
from .axes import (Cartesian2DFieldAxes, Cartesian3DFieldAxes, SketchAxes,
PolarLineAxes, XYLineAxes)
from .contour import ContourGroup
from .fieldmap import (Cartesian2DFieldmap, Cartesian2DFieldmapCollection,
Cartesian3DFieldmap, Cartesian3DFieldmapCollection,
FieldmapCollection)
from .isosurface import IsosurfaceGroup
from .streamtrace import StreamtraceRodRibbon, Streamtraces
from .vector import Vector2D, Vector3D
from . import (blanking, effects, hoe_settings, labels, linking, linemap,
rgb_coloring, scatter, slice, view)
class Plot(session.Style):
def __init__(self, frame, *svargs):
self.frame = frame
super().__init__(*svargs, uniqueid=frame.uid)
def __eq__(self, that):
return isinstance(that, type(self)) and self.frame == that.frame
def __ne__(self, that):
return not (self == that)
@contextlib.contextmanager
def activated(self):
"""Context to ensure this plot is active.
Example usage::
>>> from tecplot.constant import PlotType
>>> frame = tecplot.active_frame()
>>> frame.plot_type = PlotType.XYLine # set active plot type
>>> plot = frame.plot(PlotType.Cartesian3D) # get inactive plot
>>> print(frame.plot_type)
PlotType.XYLine
>>> with plot.activated():
... print(frame.plot_type) # 3D plot temporarily active
PlotType.Cartesian3D
>>> print(frame.plot_type) # original plot type restored
PlotType.XYLine
"""
with self.frame.activated():
orig_plot = self.frame.plot()
try:
self.activate()
yield self
finally:
orig_plot.activate()
[docs]
class SketchPlot(Plot):
"""A plot space with no data attached.
.. code-block:: python
:emphasize-lines: 5,8-9
import tecplot as tp
from tecplot.constant import PlotType
frame = tp.active_frame()
plot = frame.plot(PlotType.Sketch)
frame.add_text('Hello, World!', (36, 50), size=34)
plot.axes.x_axis.show = True
plot.axes.y_axis.show = True
tp.export.save_png('plot_sketch.png', 600, supersample=3)
.. figure:: /_static/images/plot_sketch.png
:width: 300px
:figwidth: 300px
"""
[docs]
def activate(self):
"""Make this the active plot type on the parent frame.
Example usage::
>>> from tecplot.constant import PlotType
>>> plot = frame.plot(PlotType.Sketch)
>>> plot.activate()
"""
self.frame.plot_type = PlotType.Sketch
@property
def axes(self):
"""`SketchAxes`: Axes (x and y) for the sketch plot.
Example usage::
>>> from tecplot.constant import PlotType
>>> frame.plot_type = PlotType.Sketch
>>> frame.plot().axes.x_axis.show = True
"""
return SketchAxes(self)
@property
def linking_between_frames(self):
"""`SketchPlotLinkingBetweenFrames`: Style linking between frames.
Example usage::
>>> plot.linking_between_frames.group = 1
>>> plot.linking_between_frames.link_solution_time = True
"""
return linking.SketchPlotLinkingBetweenFrames(self.frame)
@property
def linking_within_frame(self):
"""`LinkingWithinFrame`: Style linking within the frame.
Example usage::
>>> plot.linking_within_frame.link_gridline_style = True
"""
return linking.LinkingWithinFrame(self.frame)
class FieldPlot(Plot):
"""Plot containing data associated with style through fieldmaps.
.. code-block:: python
from os import path
import tecplot as tp
from tecplot.constant import PlotType
examples_dir = tp.session.tecplot_examples_directory()
infile = path.join(examples_dir, 'SimpleData', 'F18.plt')
dataset = tp.data.load_tecplot(infile)
frame = tp.active_frame()
plot = frame.plot(PlotType.Cartesian3D)
plot.activate()
plot.show_contour = True
plot.use_translucency = True
plot.contour(0).variable = dataset.variable('S')
# ensure consistent output between interactive (connected) and batch
plot.contour(0).levels.reset_to_nice()
# save image to file
tp.export.save_png('plot_field.png', 600, supersample=3)
.. figure:: /_static/images/plot_field.png
:width: 300px
:figwidth: 300px
"""
def __init__(self, frame):
super().__init__(frame, sv.FIELDLAYERS)
def contour(self, index):
"""`ContourGroup`: Plot-local `ContourGroup` style control.
Example usage::
>>> contour = frame.plot().contour(0)
>>> contour.colormap_name = 'Magma'
"""
return ContourGroup(index, self)
@property
def streamtraces(self):
"""`Streamtraces`: Plot-local `streamtrace <Streamtraces>` attributes.
Example usage::
>>> streamtraces = frame.plot().streamtraces
>>> streamtraces.color = Color.Blue
"""
return Streamtraces(self)
def slice(self, index):
tecutil.api_changed('''\
Access to 3D slice groups from 2D plots has been removed.
Use frame.plot(PlotType.Cartesian3D).slice() to access
slice groups.''', '0.13', '2018 R2')
def isosurface(self, index):
tecutil.api_changed('''\
Access to 3D isosurface groups from 2D plots has been removed.
Use frame.plot(PlotType.Cartesian3D).isosurface() to access
isosurface groups.''', '0.13', '2018 R2')
@property
def rgb_coloring(self):
"""`RGBColoring`: RGB contour flooding style control.
Example usage::
>>> plot.rgb_coloring.red_variable = dataset.variable('gas')
>>> plot.rgb_coloring.green_variable = dataset.variable('oil')
>>> plot.rgb_coloring.blue_variable = dataset.variable('water')
>>> plot.show_contour = True
>>> plot.fieldmaps().contour.flood_contour_group = plot.rgb_coloring
"""
return rgb_coloring.RGBColoring(self)
@property
def scatter(self):
"""`Scatter`: Plot-local `Scatter` style control.
Example usage::
>>> scatter = frame.plot().scatter
>>> scatter.variable = dataset.variable('P')
"""
return scatter.Scatter(self)
@property
def show_contour(self):
"""`bool`: Enable contours for this plot.
Example usage::
>>> frame.plot().show_contour = True
"""
return self._get_style(bool, sv.SHOWCONTOUR)
@show_contour.setter
def show_contour(self, show):
self._set_style(bool(show), sv.SHOWCONTOUR)
@property
def show_edge(self):
"""`bool`: Enable zone edge lines for this plot.
Example usage::
>>> frame.plot().show_edge = True
"""
return self._get_style(bool, sv.SHOWEDGE)
@show_edge.setter
def show_edge(self, show):
self._set_style(bool(show), sv.SHOWEDGE)
@property
def show_mesh(self):
"""`bool`: Enable mesh lines for this plot.
Example usage::
>>> frame.plot().show_mesh = True
"""
return self._get_style(bool, sv.SHOWMESH)
@show_mesh.setter
def show_mesh(self, show):
self._set_style(bool(show), sv.SHOWMESH)
@property
def show_scatter(self):
"""`bool`: Enable scatter symbols for this plot.
Example usage::
>>> frame.plot().show_scatter = True
"""
return self._get_style(bool, sv.SHOWSCATTER)
@show_scatter.setter
def show_scatter(self, show):
self._set_style(bool(show), sv.SHOWSCATTER)
@property
def show_shade(self):
"""`bool`: Enable surface shading effect for this plot.
Example usage::
>>> frame.plot().show_shade = True
"""
return self._get_style(bool, sv.SHOWSHADE)
@show_shade.setter
def show_shade(self, show):
self._set_style(bool(show), sv.SHOWSHADE)
@property
def show_slices(self):
"""`bool`: Show slices for this plot.
Example usage::
>>> frame.plot().show_slices(True)
"""
with self.frame.activated():
return session.get_style(bool, sv.SLICELAYERS, sv.SHOW,
uniqueid=self.frame.uid)
@show_slices.setter
def show_slices(self, show):
with self.frame.activated():
session.set_style(bool(show), sv.SLICELAYERS, sv.SHOW,
uniqueid=self.frame.uid)
@property
def show_isosurfaces(self):
"""`bool`: Show isosurfaces for this plot.
Example usage::
>>> frame.plot().show_isosurfaces(True)
"""
with self.frame.activated():
return session.get_style(bool, sv.ISOSURFACELAYERS, sv.SHOW,
uniqueid=self.frame.uid)
@show_isosurfaces.setter
def show_isosurfaces(self, show):
with self.frame.activated():
session.set_style(bool(show), sv.ISOSURFACELAYERS, sv.SHOW,
uniqueid=self.frame.uid)
@property
def show_streamtraces(self):
"""`bool`: Enable drawing `Streamtraces` on this plot.
Example usage::
>>> frame.plot().show_streamtraces = True
"""
with self.frame.activated():
return session.get_style(bool, sv.STREAMTRACELAYERS, sv.SHOW,
uniqueid=self.frame.uid)
@show_streamtraces.setter
def show_streamtraces(self, show):
with self.frame.activated():
session.set_style(bool(show), sv.STREAMTRACELAYERS, sv.SHOW,
uniqueid=self.frame.uid)
@property
def show_vector(self):
"""`bool`: Enable drawing of vectors.
Example usage::
>>> frame.plot().show_vector = True
"""
return self._get_style(bool, sv.SHOWVECTOR)
@show_vector.setter
def show_vector(self, show):
self._set_style(bool(show), sv.SHOWVECTOR)
@property
def num_fieldmaps(self):
"""`int`: Number of all fieldmaps in this plot.
Example usage::
>>> print(frame.plot().num_fieldmaps)
3
"""
return _tecutil.FieldMapGetCountForFrame(self.frame.uid)
def _fieldmap_indices(self, *keys):
result = set()
for key in tecutil.flatten_args(*keys):
if isinstance(key, FieldmapCollection):
result |= key._indices
elif isinstance(key, int):
result.add(key)
else:
index = getattr(key, 'index', self.fieldmap_index(key))
result.add(index)
return result
def fieldmap_index(self, zone):
"""The index of the fieldmap associated with a `Zone <data_access>`.
Parameters:
zone (`Zone <data_access>`): The `Zone <data_access>` object that
belongs to the `Dataset <data.Dataset>` associated with this plot.
Returns:
`Index`
Example usage::
>>> fmap_index = plot.fieldmap_index(dataset.zone('Zone'))
>>> plot.fieldmap(fmap_index).show_mesh = True
"""
with self.frame.activated():
return tecutil.Index(_tecutil.ZoneGetFieldMap(zone.index + 1) - 1)
@property
def active_fieldmap_indices(self):
"""`set`: Set of active fieldmaps by index.
This example sets the first three fieldmaps active, disabling all
others. It then turns on scatter symbols for just these three::
>>> plot.active_fieldmap_indices = [0, 1, 2]
>>> plot.fieldmaps(0, 1, 2).scatter.show = True
"""
return session.get_style(set, sv.ACTIVEFIELDMAPS,
uniqueid=self.frame.uid)
@active_fieldmap_indices.setter
def active_fieldmap_indices(self, values):
session.set_style(set(values), sv.ACTIVEFIELDMAPS,
uniqueid=self.frame.uid)
@property
def num_solution_times(self):
"""`int`: Number of solution times for all active fieldmaps.
.. note::
This only returns the number of *active* solution times. When
assigning strands and solution times to zones, the zones are
placed into an *inactive* fieldmap that must be subsequently
activated. See example below.
.. code-block:: python
>>> # place all zones into a single fieldmap (strand: 1)
>>> # with incrementing solution times
>>> for time, zone in enumerate(dataset.zones()):
... zone.strand = 1
... zone.solution_time = time
...
>>> # We must activate the fieldmap to ensure the plot's
>>> # solution times have been updated. Since we placed
>>> # all zones into a single fieldmap, we can assume the
>>> # first fieldmap (index: 0) is the one we want.
>>> plot.active_fieldmaps += [0]
>>>
>>> # now the plot's solution times are available.
>>> print(plot.num_solution_times)
10
>>> print(plot.solution_times)
[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]
.. versionadded:: 2017.2
Solution time manipulation requires Tecplot 360 2017 R2 or later.
"""
success, result = _tecutil.SolutionTimeGetNumTimeStepsForFrame(
self.frame.uid)
if not success:
raise TecplotSystemError()
return result
@property
def solution_times(self):
"""`list` of `floats <float>`: `List <list>` of active solution times.
.. note::
This only returns the list of *active* solution times. When
assigning strands and solution times to zones, the zones are placed
into an *inactive* fieldmap that must be subsequently activated.
See example below.
Example usage::
>>> print(plot.solution_times)
[0.0, 1.0, 2.0]
.. versionadded:: 2017.2
Solution time manipulation requires Tecplot 360 2017 R2 or later.
"""
res = _tecutil.SolutionTimeGetSolutionTimesForFrame(self.frame.uid)
success, ntimes, times = res
if not success:
raise TecplotSystemError()
ret = list(times[:ntimes])
if not _tecutil_connector.connected:
_tecutil.ArrayDealloc(times)
return ret
@property
def transient_zone_visibility(self):
"""`TransientZoneVisibility`: Policy to determine transient visibility of zones.
Possible values: `ZonesAtOrBeforeSolutionTime`, `ZonesAtSolutionTime`.
Example usage::
>>> from tecplot.constant import TransientZoneVisibility
>>> plot.transient_zone_visibility = \\
... TransientZoneVisibility.ZonesAtSolutionTime
.. versionadded:: 2021.2
Transient zone visibility requires Tecplot 360 2021 R2 or later.
"""
if __debug__:
reqver = (2021, 2)
if version.sdk_version_info < reqver:
msg = 'Transient zone visibility requires 2021 R2 or later.'
raise TecplotOutOfDateEngineError(reqver, msg)
style = session.Style(sv.GLOBALTIME, **self._kw)
return style._get_style(TransientZoneVisibility, sv.TRANSIENTZONEVISIBILITY)
@transient_zone_visibility.setter
def transient_zone_visibility(self, value):
if __debug__:
reqver = (2021, 2)
if version.sdk_version_info < reqver:
msg = 'Transient zone visibility requires 2021 R2 or later.'
raise TecplotOutOfDateEngineError(reqver, msg)
style = session.Style(sv.GLOBALTIME, **self._kw)
style._set_style(TransientZoneVisibility(value), sv.TRANSIENTZONEVISIBILITY)
@property
def solution_time(self):
"""`float`: The current solution time.
Example usage::
>>> print(plot.solution_times)
[0.0, 1.0, 2.0]
>>> plot.solution_time = 1.0
.. note:: **Possible side-effect when connected to Tecplot 360.**
Changing the solution times in the dataset or modifying the
active fieldmaps in a frame may trigger a change in the active
plot's solution time by the Tecplot 360 interface. This is done
to keep the GUI controls consistent. In batch mode, no such
side-effect will take place and the user must take care to set
the plot's solution time with the `plot.solution_time
<Cartesian3DFieldPlot.solution_time>` or
`plot.solution_timestep
<Cartesian3DFieldPlot.solution_timestep>` properties.
.. versionadded:: 2017.2
Solution time manipulation requires Tecplot 360 2017 R2 or later.
"""
return _tecutil.SolutionTimeGetCurrentForFrame(self.frame.uid)
@solution_time.setter
@tecutil.lock()
def solution_time(self, value):
with self.frame.activated():
res = _tecutil.SolutionTimeSetCurrent(float(value))
if res not in [SetValueReturnCode.Ok,
SetValueReturnCode.DuplicateValue]:
raise TecplotSystemError()
@property
def solution_timestep(self):
"""`int`: The zero-based index of the current solution time.
A negative index is interpreted as counting from the end of the
available solution timesteps. Example usage::
>>> print(plot.solution_times)
[0.0, 1.0, 2.0]
>>> print(plot.solution_time)
0.0
>>> plot.solution_timestep += 1
>>> print(plot.solution_time)
1.0
.. note:: **Possible side-effect when connected to Tecplot 360.**
Changing the solution times in the dataset or modifying the
active fieldmaps in a frame may trigger a change in the active
plot's solution time by the Tecplot 360 interface. This is done
to keep the GUI controls consistent. In batch mode, no such
side-effect will take place and the user must take care to set
the plot's solution time with the `plot.solution_time
<Cartesian3DFieldPlot.solution_time>` or
`plot.solution_timestep
<Cartesian3DFieldPlot.solution_timestep>` properties.
.. versionadded:: 2017.2
Solution time manipulation requires Tecplot 360 2017 R2 or later.
"""
success, result = _tecutil.SolutionTimeGetCurrentTimeStepForFrame(
self.frame.uid)
if not success:
raise TecplotSystemError()
return result - 1
@solution_timestep.setter
def solution_timestep(self, timestep):
timestep = int(timestep)
if timestep < 0:
timestep = self.num_solution_times + timestep
success, time = _tecutil.SolutionTimeGetSolutionTimeAtTimeStepForFrame(
self.frame.uid, int(timestep) + 1)
if not success:
raise TecplotSystemError()
self.solution_time = time
@property
def hoe_settings(self):
"""`FieldPlotHOESettings`: High order element settings.
Example usage::
>>> plot.hoe_settings.num_subdivision_levels = 3
"""
return hoe_settings.FieldPlotHOESettings(self.frame)
@property
def ijk_blanking(self):
"""`IJKBlanking`: Mask off cells by :math:`(i, j, k)` index.
Example usage::
>>> plot.ijk_blanking.min_percent = (50, 50)
>>> plot.ijk_blanking.active = True
"""
return blanking.IJKBlanking(self)
@property
def data_labels(self):
"""`FieldPlotDataLabels`: Node and cell labels.
This object controls displaying labels for every node and/or cell in
the dataset. Example usage::
>>> plot.data_labels.show_cell_labels = True
>>> plot.data_labels.step_index = 10
"""
return labels.FieldPlotDataLabels(self)
@property
def linking_within_frame(self):
"""`FieldPlotLinkingWithinFrame`: Style linking within the frame.
Example usage::
>>> plot.linking_within_frame.link_gridline_style = True
"""
return linking.FieldPlotLinkingWithinFrame(self.frame)
[docs]
class Cartesian2DFieldPlot(FieldPlot):
"""2D plot containing field data associated with style through fieldmaps.
.. code-block:: python
:emphasize-lines: 10-17,23-24
from os import path
import tecplot as tp
from tecplot.constant import PlotType
examples_dir = tp.session.tecplot_examples_directory()
infile = path.join(examples_dir, 'SimpleData', 'HeatExchanger.plt')
dataset = tp.data.load_tecplot(infile)
frame = tp.active_frame()
plot = frame.plot(PlotType.Cartesian2D)
plot.activate()
plot.vector.u_variable = dataset.variable('U(M/S)')
plot.vector.v_variable = dataset.variable('V(M/S)')
plot.contour(2).variable = dataset.variable('T(K)')
plot.contour(2).colormap_name = 'Sequential - Yellow/Green/Blue'
for z in dataset.zones():
fmap = plot.fieldmap(z)
fmap.contour.flood_contour_group = plot.contour(2)
plot.show_contour = True
plot.show_vector = True
# ensure consistent output between interactive (connected) and batch
plot.contour(2).levels.reset_to_nice()
# save image to file
tp.export.save_png('plot_field2d.png', 600, supersample=3)
.. figure:: /_static/images/plot_field2d.png
:width: 300px
:figwidth: 300px
"""
[docs]
def activate(self):
"""Make this the active plot type on the parent frame.
Example usage::
>>> from tecplot.constant import PlotType
>>> plot = frame.plot(PlotType.Cartesian2D)
>>> plot.activate()
"""
self.frame.plot_type = PlotType.Cartesian2D
@property
def axes(self):
"""`Cartesian2DFieldAxes`: Axes style control for this plot.
Example usage::
>>> from tecplot.constant import PlotType
>>> frame.plot_type = PlotType.Cartesian2D
>>> axes = frame.plot().axes
>>> axes.x_axis.variable = dataset.variable('U')
>>> axes.y_axis.variable = dataset.variable('V')
"""
return Cartesian2DFieldAxes(self)
[docs]
def fieldmap(self, key):
"""Returns a `Cartesian2DFieldmap` by `Zone <data_access>` or index.
Parameters:
key (`Zone <data_access>` or `int`): The `Zone <data_access>` must
be in the `Dataset <data.Dataset>` attached to the associated frame of this
plot. A negative index is interpreted as counting from the end
of the available fieldmaps.
Example usage::
>>> fmap = plot.fieldmap(dataset.zone(0))
>>> fmap.scatter.show = True
"""
if isinstance(key, int):
index = self.num_fieldmaps + key if key < 0 else key
else:
index = self.fieldmap_index(key)
return Cartesian2DFieldmap(self, index)
[docs]
def fieldmaps(self, *keys):
"""`Cartesian2DFieldmapCollection` by `Zones <data_access>` or indices.
Parameters:
keys (`list` of `Zones <data_access>` or `ints <int>`): The
`Zones <data_access>` must be in the `Dataset <data.Dataset>` attached to the
associated frame of this plot. Negative indices are interpreted
as counting from the end of the available fieldmaps.
Example usage::
>>> fmaps = plot.fieldmaps(dataset.zone(0), dataset.zone(1))
>>> fmaps.scatter.show = True
.. versionchanged:: 0.9
`fieldmaps` was changed from a property (0.8 and earlier) to a
method requiring parentheses.
"""
indices = self._fieldmap_indices(*keys)
if not indices:
indices = range(self.num_fieldmaps)
return Cartesian2DFieldmapCollection(self, *indices)
@property
def active_fieldmaps(self):
"""`Cartesian2DFieldmapCollection`: Active fieldmaps in this plot.
Example usage::
>>> plot.active_fieldmaps.vector.show = True
.. note:: **Possible side-effect when connected to Tecplot 360.**
Changing the solution times in the dataset or modifying the
active fieldmaps in a frame may trigger a change in the active
plot's solution time by the Tecplot 360 interface. This is done
to keep the GUI controls consistent. In batch mode, no such
side-effect will take place and the user must take care to set
the plot's solution time with the `plot.solution_time
<Cartesian3DFieldPlot.solution_time>` or
`plot.solution_timestep
<Cartesian3DFieldPlot.solution_timestep>` properties.
"""
indices = self.active_fieldmap_indices
return Cartesian2DFieldmapCollection(self, *indices)
@active_fieldmaps.setter
def active_fieldmaps(self, fmaps):
indices = getattr(fmaps, 'fieldmap_indices', fmaps)
self.active_fieldmap_indices = indices
@property
def vector(self):
"""`Vector2D`: Vector variable and style control for this plot.
Example usage::
>>> plot.vector.u_variable = dataset.variable('U')
"""
return Vector2D(self)
@property
def draw_order(self):
"""`TwoDDrawOrder`: The order in which objects are drawn to the screen.
Possible values: `TwoDDrawOrder.ByZone`, `TwoDDrawOrder.ByLayer`.
The order is either by `Zone <data_access>` or by visual layer
(contour, mesh, etc.)::
>>> plot.draw_order = TwoDDrawOrder.ByZone
"""
return self._get_style(TwoDDrawOrder, sv.TWODDRAWORDER)
@draw_order.setter
def draw_order(self, order):
self._set_style(TwoDDrawOrder(order), sv.TWODDRAWORDER)
@property
def view(self):
"""`Cartesian2DFieldView`: Axes orientation and limits adjustments.
Example usage::
>>> plot.view.fit()
"""
return view.Cartesian2DFieldView(self)
@property
def value_blanking(self):
"""`ValueBlanking`: Mask off cells by value.
Example usage::
>>> plot.value_blanking.constraint(0).comparison_value = 3.14
>>> plot.value_blanking.constraint(0).active = True
"""
return blanking.ValueBlankingCartesian2D(self)
@property
def linking_between_frames(self):
"""`Cartesian2DPlotLinkingBetweenFrames`: Style linking between frames.
Example usage::
>>> plot.linking_between_frames.group = 1
>>> plot.linking_between_frames.link_solution_time = True
"""
return linking.Cartesian2DPlotLinkingBetweenFrames(self.frame)
[docs]
class Cartesian3DFieldPlot(FieldPlot):
"""3D plot containing field data associated with style through fieldmaps.
.. code-block:: python
:emphasize-lines: 10-14
from os import path
import tecplot as tp
from tecplot.constant import PlotType
examples_dir = tp.session.tecplot_examples_directory()
infile = path.join(examples_dir, 'SimpleData', 'SpaceShip.lpk')
dataset = tp.load_layout(infile)
frame = tp.active_frame()
plot = frame.plot(PlotType.Cartesian3D)
plot.activate()
plot.use_lighting_effect = False
plot.show_streamtraces = False
plot.use_translucency = True
# ensure consistent output between interactive (connected) and batch
plot.contour(0).levels.reset_to_nice()
# save image to file
tp.export.save_png('plot_field3d.png', 600, supersample=3)
.. figure:: /_static/images/plot_field3d.png
:width: 300px
:figwidth: 300px
"""
[docs]
def activate(self):
"""Make this the active plot type on the parent frame.
Example usage::
>>> from tecplot.constant import PlotType
>>> plot = frame.plot(PlotType.Cartesian3D)
>>> plot.activate()
"""
self.frame.plot_type = PlotType.Cartesian3D
@property
def axes(self):
"""`Cartesian3DFieldAxes`: Axes style control for this plot.
Example usage::
>>> from tecplot.constant import PlotType
>>> frame.plot_type = PlotType.Cartesian3D
>>> axes = frame.plot().axes
>>> axes.x_axis.variable = dataset.variable('U')
>>> axes.y_axis.variable = dataset.variable('V')
>>> axes.z_axis.variable = dataset.variable('W')
"""
return Cartesian3DFieldAxes(self)
[docs]
def fieldmap(self, key):
"""Returns a `Cartesian3DFieldmap` by `Zone <data_access>` or index.
Parameters:
key (`Zone <data_access>` or `int`): The `Zone
<data_access>` must be in the `Dataset <data.Dataset>` attached to the
associated frame of this plot. A negative index is interpreted
as counting from the end of the available fieldmaps.
Example usage::
>>> fmap = plot.fieldmap(dataset.zone(0))
>>> fmap.scatter.show = True
"""
if isinstance(key, int):
index = self.num_fieldmaps + key if key < 0 else key
else:
index = self.fieldmap_index(key)
return Cartesian3DFieldmap(self, index)
[docs]
def fieldmaps(self, *keys):
"""`Cartesian3DFieldmapCollection` by `Zones <data_access>` or indices.
Parameters:
keys (`list` of `Zones <data_access>` or `integers <int>`): The
`Zones <data_access>` must be in the `Dataset <data.Dataset>` attached to the
associated frame of this plot. Negative indices are interpreted
as counting from the end of the available fieldmaps.
Example usage::
>>> fmaps = plot.fieldmaps(dataset.zone(0), dataset.zone(1))
>>> fmaps.scatter.show = True
.. versionchanged:: 0.9
`fieldmaps` was changed from a property (0.8 and earlier) to a
method requiring parentheses.
"""
indices = self._fieldmap_indices(*keys)
if not indices:
indices = range(self.num_fieldmaps)
return Cartesian3DFieldmapCollection(self, *indices)
@property
def active_fieldmaps(self):
"""`Cartesian3DFieldmapCollection`: Active fieldmaps in this plot.
Example usage::
>>> plot.active_fieldmaps.vector.show = True
.. note:: **Possible side-effect when connected to Tecplot 360.**
Changing the solution times in the dataset or modifying the
active fieldmaps in a frame may trigger a change in the active
plot's solution time by the Tecplot 360 interface. This is done
to keep the GUI controls consistent. In batch mode, no such
side-effect will take place and the user must take care to set
the plot's solution time with the `plot.solution_time
<Cartesian3DFieldPlot.solution_time>` or
`plot.solution_timestep
<Cartesian3DFieldPlot.solution_timestep>` properties.
"""
indices = self.active_fieldmap_indices
return Cartesian3DFieldmapCollection(self, *indices)
@active_fieldmaps.setter
def active_fieldmaps(self, fmaps):
indices = getattr(fmaps, 'fieldmap_indices',
[getattr(fmap, 'index', fmap) for fmap in fmaps])
self.active_fieldmap_indices = indices
[docs]
def slice(self, index):
"""`SliceGroup`: Plot-local `slice <SliceGroup>` style control.
Example usage::
>>> from tecplot.constant import Color
>>> slice0 = frame.plot().slice(0)
>>> slice0.mesh.show = True
>>> slice0.mesh.color = Color.Blue
"""
return slice.SliceGroup(self, index)
[docs]
def slices(self, *indices):
"""`SliceGroupCollection`: Plot-local slice style control.
Example setting setting mesh color of all slices to blue::
>>> from tecplot.constant import Color
>>> slices = frame.plot().slices()
>>> slices.mesh.show = True
>>> slices.mesh.color = Color.Blue
Example turning on the first two slice's contour layer::
>>> slices = frame.plot().slices(0, 1)
>>> slices.contour.show = True
"""
return slice.SliceGroupCollection(self, *indices)
[docs]
def isosurface(self, index):
"""`IsosurfaceGroup`: Plot-local `isosurface <IsosurfaceGroup>` settings.
Example usage::
>>> isosurface_0 = frame.plot().isosurface(0)
>>> isosurface_0.mesh.color = Color.Blue
"""
return IsosurfaceGroup(index, self)
@property
def vector(self):
"""`Vector3D`: Vector variable and style control for this plot.
Example usage::
>>> plot.vector.u_variable = dataset.variable('U')
"""
return Vector3D(self)
@property
def view(self):
"""`Cartesian3DView`: Viewport, axes orientation and limits adjustments.
Example usage::
>>> plot.view.fit()
"""
return view.Cartesian3DView(self)
@property
def use_lighting_effect(self):
"""`bool`: Enable lighting effect for all objects within this plot.
Example usage::
>>> frame.plot().use_lighting_effect = True
"""
return self._get_style(bool, sv.USELIGHTINGEFFECT)
@use_lighting_effect.setter
def use_lighting_effect(self, value):
self._set_style(bool(value), sv.USELIGHTINGEFFECT)
@property
def use_translucency(self):
"""`bool`: Enable translucent effect for all objects within this plot.
Example usage::
>>> frame.plot().use_translucency = True
"""
return self._get_style(bool, sv.USETRANSLUCENCY)
@use_translucency.setter
def use_translucency(self, show):
self._set_style(bool(show), sv.USETRANSLUCENCY)
@property
def light_source(self):
"""`LightSource`: Control the direction and effects of lighting.
Example usage::
>>> plot.light_source.intensity = 70.0
"""
return effects.LightSource(self)
@property
def value_blanking(self):
"""`ValueBlanking`: Mask off cells by value.
Example usage::
>>> plot.value_blanking.constraint(0).comparison_value = 3.14
>>> plot.value_blanking.constraint(0).active = True
"""
return blanking.ValueBlankingCartesian3D(self)
@property
def line_lift_fraction(self):
"""`float`: Lift lines above plot by percentage distance to the eye.
Example usage::
>>> plot.line_lift_fraction = 0.6
"""
style = session.Style(sv.GLOBALTHREED, **self._kw)
return style._get_style(float, sv.LINELIFTFRACTION)
@line_lift_fraction.setter
def line_lift_fraction(self, value):
style = session.Style(sv.GLOBALTHREED, **self._kw)
style._set_style(float(value), sv.LINELIFTFRACTION)
@property
def near_plane_fraction(self):
"""`float`: position of the "near plane".
In a 3D plot, the "near plane" acts as a windshield. Anything in front
of this plane does not display. Example usage::
>>> plot.near_plane_fraction = 0.1
"""
style = session.Style(sv.GLOBALTHREED, **self._kw)
return style._get_style(float, sv.NEARPLANEFRACTION)
@near_plane_fraction.setter
def near_plane_fraction(self, value):
style = session.Style(sv.GLOBALTHREED, **self._kw)
style._set_style(float(value), sv.NEARPLANEFRACTION)
@property
def perform_extra_sorting(self):
"""`bool`: Use a more robust depth sorting algorithm for display.
When printing 3D plots in a vector graphics format, Tecplot 360 must
sort the objects so that it can draw those farthest from the screen
first and those closest to the screen last. By default, Tecplot 360
uses a quick sorting algorithm. This is not always accurate and does
not detect problems such as intersecting objects. When
``perform_extra_sorting`` set to `True`, Tecplot 360 uses a slower,
more accurate approach that detects and resolves such problems. Example
usage::
>>> plot.perform_extra_sorting = True
"""
style = session.Style(sv.GLOBALTHREED, **self._kw)
return style._get_style(bool, sv.PERFORMEXTRA3DSORTING)
@perform_extra_sorting.setter
def perform_extra_sorting(self, value):
style = session.Style(sv.GLOBALTHREED, **self._kw)
style._set_style(bool(value), sv.PERFORMEXTRA3DSORTING)
@property
def symbol_lift_fraction(self):
"""`float`: Lift symbols above plot by percentage distance to the eye.
Example usage::
>>> plot.symbol_lift_fraction = 0.6
"""
style = session.Style(sv.GLOBALTHREED, **self._kw)
return style._get_style(float, sv.SYMBOLLIFTFRACTION)
@symbol_lift_fraction.setter
def symbol_lift_fraction(self, value):
style = session.Style(sv.GLOBALTHREED, **self._kw)
style._set_style(float(value), sv.SYMBOLLIFTFRACTION)
@property
def vector_lift_fraction(self):
"""`float`: Lift vectors above plot by percentage distance to the eye.
Example usage::
>>> plot.vector_lift_fraction = 0.6
"""
style = session.Style(sv.GLOBALTHREED, **self._kw)
return style._get_style(float, sv.VECTORLIFTFRACTION)
@vector_lift_fraction.setter
def vector_lift_fraction(self, value):
style = session.Style(sv.GLOBALTHREED, **self._kw)
style._set_style(float(value), sv.VECTORLIFTFRACTION)
@property
def linking_between_frames(self):
"""`Cartesian3DPlotLinkingBetweenFrames`: Style linking between frames.
Example usage::
>>> plot.linking_between_frames.group = 1
>>> plot.linking_between_frames.link_solution_time = True
"""
return linking.Cartesian3DPlotLinkingBetweenFrames(self.frame)
class LinePlot(Plot):
"""Plot with line data and associated style through linemaps.
.. code-block:: python
from os import path
import tecplot as tp
from tecplot.constant import PlotType, Color, LinePattern
examples_dir = tp.session.tecplot_examples_directory()
infile = path.join(examples_dir, 'SimpleData', 'Rainfall.dat')
dataset = tp.data.load_tecplot(infile)
frame = tp.active_frame()
frame.plot_type = PlotType.XYLine
plot = frame.plot()
plot.show_symbols = True
# save image to file
tp.export.save_png('plot_line.png', 600, supersample=3)
.. figure:: /_static/images/plot_line.png
:width: 300px
:figwidth: 300px
"""
def __init__(self, frame):
super().__init__(frame, sv.LINEPLOTLAYERS)
@tecutil.lock()
def delete_linemaps(self, *linemaps):
r"""Clear all linemaps within this plot.
Parameters:
\*linemaps (:ref:`Linemap`, `int` or `str`):
One or more of the following: :ref:`Linemap` objects, linemap
indices (zero-based) or linemap names. If none are given, all
linemaps will be deleted.
Example usage::
>>> plot.delete_linemaps()
>>> print(plot.num_linemaps)
0
"""
if not linemaps:
return _tecutil.LineMapDelete(None)
with tecutil.IndexSet() as indices:
for lmap in tecutil.flatten_args(*linemaps):
try:
# try as a Linemap object
indices.append(lmap.index)
except (AttributeError, TypeError):
try:
# try as a linemap index
indices.append(lmap)
except TypeError:
# assume name pattern
for submap in self.linemaps(lmap):
indices.append(submap.index)
return _tecutil.LineMapDelete(indices)
@property
def num_linemaps(self):
"""`int`: Number of linemaps held by this plot.
Example usage::
>>> print(plot.num_linemaps)
3
"""
return _tecutil.LineMapGetCountForFrame(self.frame.uid)
def _linemap_indices_by_name(self, pattern):
pattern_type = getattr(re, 'Pattern', getattr(re, '_pattern_type', None))
if not isinstance(pattern, pattern_type):
regex = re.compile(fnmatch.translate(pattern), re.IGNORECASE)
else:
regex = pattern
indices = set()
with self.frame.activated():
found = False
for i in range(self.num_linemaps):
try:
_, name = _tecutil.LineMapGetName(i + 1)
name = name or ''
except (AttributeError, TecplotSystemError):
name = ''
if regex.match(name):
found = True
indices.add(i)
if __debug__:
if (
not found and
isinstance(pattern, str) and
any(c in pattern for c in '*?[]')
):
msg = 'no linemaps found matching: "{}"'.format(pattern)
warning = TecplotPatternMatchWarning(pattern, msg)
warnings.warn(warning)
return indices
def _linemap_indices(self, *keys):
"""
convert keys to a set of indices where keys are:
* int: get one linemap index (converting negative values)
* regex pattern: match by name
* glob-style string: match by name
if no keys are given, get all linemaps indices
"""
indices = set()
if keys:
for key in keys:
if isinstance(key, int):
index = key + self.num_linemaps if key < 0 else key
if index >= self.num_linemaps:
msg = 'linemap index out of range: ' + str(index)
raise TecplotIndexError(msg)
indices.add(index)
else:
indices |= self._linemap_indices_by_name(key)
else:
indices |= set(range(self.num_linemaps))
return indices
@tecutil.lock()
def _add_linemap(self, name, zone, show=True):
with self.frame.activated():
new_linemap_index = self.num_linemaps
if not _tecutil.LineMapCreate():
raise TecplotSystemError()
linemap = self.linemap(new_linemap_index)
if name is not None:
linemap.name = name
if zone is not None:
linemap.zone_index = getattr(zone, 'index', zone)
if show is not None:
linemap.show = show
return linemap
@property
def legend(self):
"""`LineLegend`: Line plot legend style and placement control.
Example usage::
>>> plot.legend.show = True
"""
return legend.LineLegend(self)
@property
def active_linemap_indices(self):
"""`set` of `integers <int>`: `set` of all active linemaps by index.
Numbers are zero-based indices to the linemaps::
>>> active_indices = plot.active_linemap_indices
>>> active_lmaps = [plot.linemap(i) for i in active_indices]
"""
return session.get_style(set, sv.ACTIVELINEMAPS,
uniqueid=self.frame.uid)
@property
def show_lines(self):
"""`bool`: Enable lines for this plot.
Example usage::
>>> plot.show_lines = True
"""
return self._get_style(bool, sv.SHOWLINES)
@show_lines.setter
def show_lines(self, value):
self._set_style(bool(value), sv.SHOWLINES)
@property
def show_symbols(self):
"""`bool`: Enable symbols at line vertices for this plot.
Example usage::
>>> plot.show_symbols = True
"""
return self._get_style(bool, sv.SHOWSYMBOLS)
@show_symbols.setter
def show_symbols(self, value):
self._set_style(bool(value), sv.SHOWSYMBOLS)
@property
def value_blanking(self):
"""`ValueBlanking`: Mask off points by value.
Example usage::
>>> plot.value_blanking.constraint(0).comparison_value = 3.14
>>> plot.value_blanking.constraint(0).active = True
"""
return blanking.ValueBlanking(self)
@property
def base_font(self):
"""`BaseFont`: Default typeface style control.
Example usage::
>>> plot.base_font.typeface = 'Times'
"""
return text.BaseFont(sv.GLOBALLINEPLOT, **self._kw)
@property
def data_labels(self):
"""`LinePlotDataLabels`: Node and cell labels.
This object controls displaying labels for every node and/or cell in
the dataset. Example usage::
>>> plot.data_labels.show_node_labels = True
>>> plot.data_labels.step_index = 10
"""
return labels.LinePlotDataLabels(self)
@property
def linking_within_frame(self):
"""`DataPlotLinkingWithinFrame`: Style linking within the frame.
Example usage::
>>> plot.linking_within_frame.link_gridline_style = True
"""
return linking.DataPlotLinkingWithinFrame(self.frame)
[docs]
class XYLinePlot(LinePlot):
"""Cartesian plot with line data and associated style through linemaps.
.. code-block:: python
:emphasize-lines: 10-14
from os import path
import tecplot as tp
from tecplot.constant import PlotType, FillMode
examples_dir = tp.session.tecplot_examples_directory()
infile = path.join(examples_dir, 'SimpleData', 'SunSpots.plt')
dataset = tp.data.load_tecplot(infile)
frame = tp.active_frame()
plot = frame.plot(PlotType.XYLine)
plot.activate()
plot.show_symbols = True
plot.linemap(0).symbols.fill_mode = FillMode.UseLineColor
plot.linemap(0).symbols.size = 1
tp.export.save_png('plot_xyline.png', 600, supersample=3)
.. figure:: /_static/images/plot_xyline.png
:width: 300px
:figwidth: 300px
"""
[docs]
def activate(self):
"""Make this the active plot type on the parent frame.
Example usage::
>>> from tecplot.constant import PlotType
>>> plot = frame.plot(PlotType.XYLine)
>>> plot.activate()
"""
self.frame.plot_type = PlotType.XYLine
[docs]
def linemaps(self, *keys):
"""`XYLinemapCollection` by index or name.
Parameters:
keys (`int`, `str` or `re.Pattern <re.compile>`): Zero-based
index, case-insensitive `glob-style pattern string
<fnmatch.fnmatch>` or a compiled `regex pattern instance
<re.compile>` used to match the linemaps by name. A negative
index is interpreted as counting from the end of the available
linemaps.
Example usage, adjusting the line thickness for all lines in the plot::
>>> plot.linemaps().line.line_thickness = 1.4
"""
indices = self._linemap_indices(*keys)
return linemap.XYLinemapCollection(self, *indices)
[docs]
def linemap(self, pattern):
"""Returns a specific linemap within this plot.
Parameters:
pattern (`int`, `str` or `re.Pattern <re.compile>`): Zero-based
index, case-insensitive
`glob-style pattern string <fnmatch.fnmatch>` or a compiled
`regex pattern instance <re.compile>` used to match the
linemaps by name. A negative index is interpreted as counting
from the end of the available linemaps.
Returns:
`XYLinemap` corresponding to *pattern* or `None` if *pattern* was
passed in as a `str` or `regex pattern instance <re.compile>` and
no matching linemap was found.
.. note::
Plots can contain linemaps with identical names and only the first
match found is returned. This is not guaranteed to be deterministic
and care should be taken to have only linemaps with unique names
when this feature is used.
Example usage::
>>> plot.linemap(0).error_bar.show = True
"""
try:
return next(iter(self.linemaps(pattern)))
except StopIteration:
pass
@property
def active_linemaps(self):
"""`XYLinemapCollection`: Active linemaps in this plot.
Example usage::
>>> plot.active_linemaps.show_symbols = True
"""
indices = self.active_linemap_indices
return linemap.XYLinemapCollection(self, *indices)
[docs]
def add_linemap(self, name=None, zone=None, x=None, y=None, show=True):
"""Add a linemap using the specified zone and variables.
Parameters:
name (`str`): Name of the linemap which can be used for
retrieving with `XYLinePlot.linemap`. If `None`, then the
linemap will not have a name. Default: `None`.
zone (`Zone <data_access>`): The data to be used when drawing this
linemap. If `None`, then |Tecplot Engine| will select a zone.
Default: `None`.
x (`Variable`): The ``x`` variable which must be from the same
`Dataset <data.Dataset>` as ``y`` and ``zone``. If `None`, then
|Tecplot Engine| will select an x variable. Default: `None`.
y (`Variable`): The ``y`` variable which must be from the same
`Dataset <data.Dataset>` as ``x`` and ``zone``. If `None`, then
|Tecplot Engine| will select a ``y`` variable. Default: `None`.
show (`bool`, optional): Enable this linemap as soon as
it's added. (default: `True`). If `None`, then |Tecplot Engine|
will determine if the linemap should be enabled.
Returns:
`XYLinemap`
Example usage::
>>> lmap = plot.add_linemap('Line 1', dataset.zone('Zone'),
... dataset.variable('X'),
... dataset.variable('Y'))
>>> lmap.line.line_thickness = 0.8
"""
lmap = self._add_linemap(name, zone, show)
if x is not None:
lmap.x_variable = x
if y is not None:
lmap.y_variable = y
return lmap
@property
def axes(self):
"""`XYLineAxes`: Axes style control for this plot.
Example usage::
>>> from tecplot.constant import PlotType, AxisMode
>>> frame.plot_type = PlotType.XYLine
>>> axes = frame.plot().axes
>>> axes.axis_mode = AxisMode.XYDependent
>>> axes.xy_ratio = 2
"""
return XYLineAxes(self)
@property
def show_bars(self):
"""`bool`: Enable bar chart drawing mode for this plot.
Example usage::
>>> plot.show_bars = True
"""
return self._get_style(bool, sv.SHOWBARCHARTS)
@show_bars.setter
def show_bars(self, value):
self._set_style(bool(value), sv.SHOWBARCHARTS)
@property
def show_error_bars(self):
"""`bool`: Enable error bars for this plot.
The variable to be used for error bars must be set first on at least
one linemap within this plot::
>>> plot.linemap(0).error_bars.variable = dataset.variable('E')
>>> plot.show_error_bars = True
"""
return self._get_style(bool, sv.SHOWERRORBARS)
@show_error_bars.setter
def show_error_bars(self, value):
self._set_style(bool(value), sv.SHOWERRORBARS)
@property
def view(self):
"""`XYLineView`: View control of the plot relative to the frame.
Example usage::
>>> plot.view.fit()
"""
return view.XYLineView(self)
@property
def linking_between_frames(self):
"""`XYLinePlotLinkingBetweenFrames`: Style linking between frames.
Example usage::
>>> plot.linking_between_frames.group = 1
>>> plot.linking_between_frames.link_solution_time = True
"""
return linking.XYLinePlotLinkingBetweenFrames(self.frame)
[docs]
class PolarLinePlot(LinePlot):
"""Polar plot with line data and associated style through linemaps.
.. code-block:: python
:emphasize-lines: 16-22
import numpy as np
import tecplot as tp
from tecplot.constant import *
frame = tp.active_frame()
npoints = 300
r = np.linspace(0, 2000, npoints)
theta = np.linspace(0, 10, npoints)
dataset = frame.create_dataset('Data', ['R', 'Theta'])
zone = dataset.add_ordered_zone('Zone', (300,))
zone.values('R')[:] = r
zone.values('Theta')[:] = theta
plot = frame.plot(PlotType.PolarLine)
plot.activate()
plot.axes.r_axis.max = r.max()
plot.axes.theta_axis.mode = ThetaMode.Radians
plot.delete_linemaps()
lmap = plot.add_linemap('Linemap', zone, dataset.variable('R'),
dataset.variable('Theta'))
lmap.line.line_thickness = 0.8
lmap.line.color = Color.Green
plot.view.fit()
tp.export.save_png('plot_polar.png', 600, supersample=3)
.. figure:: /_static/images/plot_polar.png
:width: 300px
:figwidth: 300px
"""
[docs]
def activate(self):
"""Make this the active plot type on the parent frame.
Example usage::
>>> from tecplot.constant import PlotType
>>> plot = frame.plot(PlotType.PolarLine)
>>> plot.activate()
"""
self.frame.plot_type = PlotType.PolarLine
@property
def axes(self):
"""`PolarLineAxes`: Axes style control for this plot.
Example usage::
>>> from tecplot.constant import PlotType, ThetaMode
>>> frame.plot_type = PlotType.PolarLine
>>> axes = frame.plot().axes
>>> axes.theta_mode = ThetaMode.Radians
"""
return PolarLineAxes(self)
@property
def view(self):
"""`PolarView`: View control of the plot relative to the frame.
Example usage::
>>> plot.view.fit()
"""
return view.PolarView(self)
[docs]
def add_linemap(self, name=None, zone=None, r=None, theta=None, show=True):
"""Add a linemap using the specified zone and variables.
Parameters:
name (`str`): Name of the linemap which can be used for
retrieving with `PolarLinePlot.linemap`. If `None`, then the
linemap will not have a name. Default: `None`.
zone (`Zone <data_access>`): The data to be used when drawing this
linemap. If `None`, then |Tecplot Engine| will select a
`Zone <data_access>`.
Default: `None`.
r (`Variable`): The ``r`` variable which must be from the same
`Dataset <data.Dataset>` as ``theta`` and ``zone``. If `None`, then
|Tecplot Engine| will select a variable. Default: `None`.
theta (`Variable`): The ``theta`` variable which must be from the
same `Dataset <data.Dataset>` as ``r`` and ``zone``. If `None`, then
|Tecplot Engine| will select a variable. Default: `None`.
show (`bool`, optional): Enable this linemap as soon as
it's added. (default: `True`)
Returns:
`PolarLinemap`
Example usage::
>>> lmap = plot.add_linemap('Line 1', dataset.zone('Zone'),
... dataset.variable('R'),
... dataset.variable('Theta'))
>>> lmap.line.line_thickness = 0.8
"""
lmap = self._add_linemap(name, zone, show)
if r is not None:
lmap.r_variable = r
if theta is not None:
lmap.theta_variable = theta
return lmap
[docs]
def linemaps(self, *keys):
"""`PolarLinemapCollection` by index or name.
Parameters:
keys (`int`, `str` or `re.Pattern <re.compile>`): Zero-based
index, case-insensitive `glob-style pattern string
<fnmatch.fnmatch>` or a compiled `regex pattern instance
<re.compile>` used to match the linemaps by name. A negative
index is interpreted as counting from the end of the available
linemaps.
Example usage, adjusting the line thickness for all lines in the plot::
>>> plot.linemaps().line.line_thickness = 1.4
"""
indices = self._linemap_indices(*keys)
return linemap.PolarLinemapCollection(self, *indices)
[docs]
def linemap(self, pattern):
"""Returns a specific linemap within this plot.
Parameters:
pattern (`int`, `str` or `re.Pattern <re.compile>`): Zero-based
index, case-insensitive
`glob-style pattern string <fnmatch.fnmatch>` or a compiled
`regex pattern instance <re.compile>` used to match the
linemaps by name. A negative index is interpreted as counting
from the end of the available linemaps.
Returns:
`PolarLinemap` corresponding to *pattern* or `None` if *pattern*
was passed in as a `str` or `regex pattern instance <re.compile>`
and no matching linemap was found.
.. note::
Plots can contain linemaps with identical names and only the first
match found is returned. This is not guaranteed to be deterministic
and care should be taken to have only linemaps with unique names
when this feature is used.
Example usage::
>>> plot.linemap(0).error_bar.show = True
"""
try:
return next(iter(self.linemaps(pattern)))
except StopIteration:
pass
@property
def active_linemaps(self):
"""`PolarLinemapCollection`: Active linemaps in this plot.
Example usage::
>>> plot.active_linemaps.show_symbols = True
"""
indices = self.active_linemap_indices
return linemap.PolarLinemapCollection(self, *indices)
@property
def linking_between_frames(self):
"""`PolarPlotLinkingBetweenFrames`: Style linking between frames.
Example usage::
>>> plot.linking_between_frames.group = 1
>>> plot.linking_between_frames.link_solution_time = True
"""
return linking.PolarPlotLinkingBetweenFrames(self.frame)
