Source code for tecplot.plot.slice

from builtins import int, super

import itertools as it

from collections.abc import Iterable

from ..tecutil import _tecutil, sv
from ..constant import *
from ..exception import *
from .. import session, tecutil, version


[docs]class SliceMesh(session.SubStyle): """Mesh attributes of the slice group. .. code-block:: python :emphasize-lines: 12 from os import path import tecplot as tp from tecplot.constant import SliceSurface, ContourType examples_dir = tp.session.tecplot_examples_directory() datafile = path.join(examples_dir, 'SimpleData', 'DuctFlow.plt') dataset = tp.data.load_tecplot(datafile) plot = tp.active_frame().plot() plot.show_slices = True plot.contour(0).variable = dataset.variable('U(M/S)') plot.slice(0).mesh.show = True # ensure consistent output between interactive (connected) and batch plot.contour(0).levels.reset_to_nice() tp.export.save_png('slice_mesh.png', 600, supersample=3) .. figure:: /_static/images/slice_mesh.png :width: 300px :figwidth: 300px """ def __init__(self, slice_group): super().__init__(slice_group, sv.MESH) @property def show(self): """`bool`: Show mesh lines. Example usage:: >>> plot.slice(0).mesh.show = True """ return self._get_style(bool, sv.SHOW) @show.setter def show(self, value): self._set_style(bool(value), sv.SHOW) @property def color(self): """`Color` or `ContourGroup`: Slice mesh line Color. Slice mesh lines can be a solid color or be colored by a `ContourGroup` as obtained through the ``plot.contour`` property. Example usage:: >>> plot.slice(0).mesh.show = True >>> plot.slice(0).mesh.color = Color.Green """ return tecutil.color_spec(self._get_style(Color, sv.COLOR), self.parent.plot) @color.setter def color(self, value): self._set_style(tecutil.color_spec(value), sv.COLOR) @property def line_thickness(self): """`float`: Mesh line thickness. The mesh line thickness is specified as a percentage of the frame width. Example usage:: >>> plot.slice(0).mesh.show = True >>> plot.slice(0).mesh.line_thickness = 0.8 """ return self._get_style(float, sv.LINETHICKNESS) @line_thickness.setter def line_thickness(self, value): self._set_style(float(value), sv.LINETHICKNESS)
[docs]class SliceShade(session.SubStyle): """Shade attributes of the slice group. Show shading on the slice when `SliceContour.show` has not been selected or is set to `ContourType.Lines`: .. code-block:: python :emphasize-lines: 11-14 from os import path import tecplot as tp from tecplot.constant import Color examples_dir = tp.session.tecplot_examples_directory() datafile = path.join(examples_dir, 'SimpleData', 'Pyramid.plt') dataset = tp.data.load_tecplot(datafile) plot = tp.active_frame().plot() plot.show_slices = True plot.slice(0).contour.show = False shade = plot.slice(0).shade shade.show = True shade.color = Color.Red # Slice will be colored solid red. tp.export.save_png('slice_shade.png', 600, supersample=3) .. figure:: /_static/images/slice_shade.png :width: 300px :figwidth: 300px """ def __init__(self, slice_group): super().__init__(slice_group, sv.SHADE) @property def show(self): """`bool`: Show shade attributes. Example usage:: >>> plot.slice(0).shade.show = True """ return self._get_style(bool, sv.SHOW) @show.setter def show(self, value): self._set_style(bool(value), sv.SHOW) @property def color(self): """`Color`: Shade color. `Color.MultiColor` and `Color.RGBColor` coloring are not available. Use flooded contours for multi-color or RGB flooding Example usage:: >>> plot.slice(0).shade.show = True >>> plot.slice(0).shade.color = Color.Blue """ return self._get_style(Color, sv.COLOR) @color.setter def color(self, value): self._set_style(Color(value), sv.COLOR) @property def use_lighting_effect(self): """`bool`: Use lighting effect. When set to `True`, the lighting effect may be selected with the `SliceEffects.lighting_effect` attribute. .. note:: Setting `SliceShade.use_lighting_effect` will also set the same value for `SliceContour.use_lighting_effect`, and vice-versa. Example usage:: >>> plot.slice(0).shade.use_lighting_effect = True >>> plot.slice(0).effects.lighting_effect = LightingEffect.Paneled """ return self._get_style(bool, sv.USELIGHTINGEFFECT) @use_lighting_effect.setter def use_lighting_effect(self, value): self._set_style(bool(value), sv.USELIGHTINGEFFECT)
[docs]class SliceEffects(session.SubStyle): """Slice effects for this slice. .. code-block:: python :emphasize-lines: 16-17 from os import path import tecplot as tp examples_dir = tp.session.tecplot_examples_directory() datafile = path.join(examples_dir, 'SimpleData', 'DuctFlow.plt') dataset = tp.data.load_tecplot(datafile) plot = tp.active_frame().plot() plot.show_slices = True slice_0 = plot.slice(0) plot.contour(0).variable = dataset.variable('U(M/S)') slice_0.contour.show = True slice_0.effects.use_translucency = True slice_0.effects.surface_translucency = 70 # ensure consistent output between interactive (connected) and batch plot.contour(0).levels.reset_to_nice() tp.export.save_png('slice_effects.png', 600, supersample=3) .. figure:: /_static/images/slice_effects.png :width: 300px :figwidth: 300px """ def __init__(self, slice_group): super().__init__(slice_group, sv.EFFECTS) @property def lighting_effect(self): """`LightingEffect`: Surface lighting effect. Slice lighting effects must be enabled by setting `SliceContour.use_lighting_effect` or `SliceShade.use_lighting_effect` to `True` when setting this value. There are two types of lighting effects: Paneled and Gouraud: * `Paneled`: Within each cell, the color assigned to each area by shading or contour flooding is tinted by a shade constant across the cell. This shade is based on the orientation of the cell relative to your 3D light source. * `Gouraud`: This offers smoother, more continuous shading than Paneled shading, but it also results in slower plotting and larger print files. `Gouraud` shading is not continuous across zone boundaries unless face neighbors are specified in the data. `Gouraud` shading is not available for finite element volume `Zones <data_access>` when blanking is active. The zone's lighting effect reverts to `Paneled` shading in this case. Example usage:: >>> plot.slice(0).contour.use_lighting_effect = True >>> plot.slice(0).effects.lighting_effect = LightingEffect.Paneled """ return self._get_style(LightingEffect, sv.LIGHTINGEFFECT) @lighting_effect.setter def lighting_effect(self, value): self._set_style(LightingEffect(value), sv.LIGHTINGEFFECT) @property def surface_translucency(self): """`int`: Surface translucency of the slice group. Slice surface translucency must be enabled by setting `SliceEffects.use_translucency` = `True` when setting this value. Valid slice translucency values range from one (opaque) to 99 (translucent). Example usage:: >>> plot.slice(0).effects.use_translucency = True >>> plot.slice(0).effects.surface_translucency = 20 """ return self._get_style(int, sv.SURFACETRANSLUCENCY) @surface_translucency.setter def surface_translucency(self, value): self._set_style(int(value), sv.SURFACETRANSLUCENCY) @property def use_translucency(self): """`bool`: Enable surface translucency for this slice group. The surface translucency value can be changed by setting `SliceEffects.surface_translucency`. Example usage:: >>> plot.slice(0).effects.use_translucency = True >>> plot.slice(0).effects.surface_translucency = 20 """ return self._get_style(bool, sv.USETRANSLUCENCY) @use_translucency.setter def use_translucency(self, value): self._set_style(bool(value), sv.USETRANSLUCENCY)
[docs]class SliceEdge(session.SubStyle): """Edge attributes of the slice group. When enabled, selected edge lines of all slices in this group will be shown: .. code-block:: python :emphasize-lines: 13-14 from os import path import tecplot as tp examples_dir = tp.session.tecplot_examples_directory() datafile = path.join(examples_dir, 'SimpleData', 'DuctFlow.plt') dataset = tp.data.load_tecplot(datafile) plot = tp.active_frame().plot() plot.show_slices = True plot.contour(0).variable = dataset.variable('U(M/S)') slice_0 = plot.slice(0) slice_0.edge.show = True slice_0.edge.line_thickness = 0.8 # ensure consistent output between interactive (connected) and batch plot.contour(0).levels.reset_to_nice() tp.export.save_png('slice_edge.png', 600, supersample=3) .. figure:: /_static/images/slice_edge.png :width: 300px :figwidth: 300px """ def __init__(self, slice_group): super().__init__(slice_group, sv.EDGELAYER) @property def edge_type(self): """`EdgeType`: Edge type. There are two types of edges in |Tecplot 360|: creases and borders. An edge border is the boundary of a `Zone <data_access>`. An edge crease appears when the inside angle between two cells is less than a user-defined limit. The inside angle can range from 0-180 degrees (where 180 degrees indicates coplanar surfaces). The default inside angle for determining an edge crease is 135 degrees. Example usage:: >>> plot.slice(0).edge.show = True >>> plot.slice(0).edge.edge_type = EdgeType.BordersAndCreases """ return self._get_style(EdgeType, sv.EDGETYPE) @edge_type.setter def edge_type(self, value): self._set_style(EdgeType(value), sv.EDGETYPE) @property def show(self): """`bool`: Show edges. This property must be set to `True` to show any of the other edge properties. Example usage:: >>> plot.slice(0).edge.show = True >>> plot.slice(0).edge.edge_type = EdgeType.BordersAndCreases """ return self._get_style(bool, sv.SHOW) @show.setter def show(self, value): self._set_style(bool(value), sv.SHOW) @property def color(self): """`Color`: Edge color. Example usage:: >>> plot.slice(0).edge.show = True >>> plot.slice(0).edge.color = Color.Blue """ return self._get_style(Color, sv.COLOR) @color.setter def color(self, value): self._set_style(Color(value), sv.COLOR) @property def line_thickness(self): """`float`: Edge line thickness as a percentage of frame width. Example usage:: >>> plot.slice(0).edge.show = True >>> plot.slice(0).edge.line_thickness = .8 """ return self._get_style(float, sv.LINETHICKNESS) @line_thickness.setter def line_thickness(self, value): self._set_style(float(value), sv.LINETHICKNESS)
[docs]class SliceVector(session.SubStyle): """Vector attributes of the slice group. .. code-block:: python :emphasize-lines: 22-25 from os import path import tecplot as tp from tecplot.constant import * examples_dir = tp.session.tecplot_examples_directory() datafile = path.join(examples_dir, 'SimpleData', 'DuctFlow.plt') dataset = tp.data.load_tecplot(datafile) plot = tp.active_frame().plot() plot.show_slices = True slice_0 = plot.slice(0) plot.contour(0).variable = dataset.variable('T(K)') # Vector variables must be assigned before displaying vectors = plot.vector vectors.u_variable = dataset.variable('U(M/S)') vectors.v_variable = dataset.variable('V(M/S)') vectors.w_variable = dataset.variable('W(M/S)') slice_vector = plot.slice(0).vector slice_vector.show = True slice_vector.vector_type = VectorType.MidAtPoint slice_vector.color = Color.BluePurple slice_0.effects.use_translucency = True slice_0.effects.surface_translucency = 30 # ensure consistent output between interactive (connected) and batch plot.contour(0).levels.reset_to_nice() tp.export.save_png('slice_vector.png', 600, supersample=3) .. figure:: /_static/images/slice_vector.png :width: 300px :figwidth: 300px """ def __init__(self, slice_group): super().__init__(slice_group, sv.VECTOR) @property def show(self): """`bool`: Show vectors on slices. Example usage:: >>> plot.slice(0).vector.show = True """ return self._get_style(bool, sv.SHOW) @show.setter def show(self, value): self._set_style(bool(value), sv.SHOW) @property def color(self): """`Color`: Set slice vector color. Example usage:: >>> plot.slice(0).vector.show = True >>> plot.slice(0).vector.color = Color.Red """ return self._get_style(Color, sv.COLOR) @color.setter def color(self, value): self._set_style(Color(value), sv.COLOR) @property def is_tangent(self): """`bool`: Use tangent vectors for slices. Example usage:: >>> plot.slice(0).vector.show = True >>> plot.slice(0).vector.is_tangent = True """ return self._get_style(bool, sv.ISTANGENT) @is_tangent.setter def is_tangent(self, value): self._set_style(bool(value), sv.ISTANGENT) @property def line_thickness(self): """`float`: Vector line thickness as a percentage of the frame height. Typical values are .02, .1, .4, .8, 1.5 Example usage:: >>> plot.slice(0).vector.show = True >>> plot.slice(0).vector.line_thickness = .1 """ return self._get_style(float, sv.LINETHICKNESS) @line_thickness.setter def line_thickness(self, value): self._set_style(float(value), sv.LINETHICKNESS) @property def vector_type(self): """`VectorType`: Type of vector for slices in this slice group. Example usage:: >>> plot.slice(0).vector.show = True >>> plot.slice(0).vector.vector_type = VectorType.MidAtPoint """ return self._get_style(VectorType, sv.VECTORTYPE) @vector_type.setter def vector_type(self, value): self._set_style(VectorType(value), sv.VECTORTYPE) @property def arrowhead_style(self): """`ArrowheadStyle`: Arrowhead style of slice vectors. Example usage:: >>> plot.slice(0).vector.show = True >>> plot.slice(0).vector.arrowhead_style = ArrowheadStyle.Hollow """ return self._get_style(ArrowheadStyle, sv.ARROWHEADSTYLE) @arrowhead_style.setter def arrowhead_style(self, value): self._set_style(ArrowheadStyle(value), sv.ARROWHEADSTYLE)
[docs]class SliceContour(session.SubStyle): """Contour attributes of the slice group. .. code-block:: python :emphasize-lines: 18-21 from os import path import tecplot as tp from tecplot.constant import SliceSurface, ContourType examples_dir = tp.session.tecplot_examples_directory() datafile = path.join(examples_dir, 'SimpleData', 'DuctFlow.plt') dataset = tp.data.load_tecplot(datafile) plot = tp.active_frame().plot() plot.show_slices = True slice_0 = plot.slice(0) # Use contour(0) for Flooding and contour(2) for Lines plot.contour(0).variable = dataset.variable('P(N/m2)') plot.contour(2).variable = dataset.variable('T(K)') plot.contour(2).legend.show = False slice_0.contour.show = True slice_0.contour.flood_contour_group = plot.contour(0) slice_0.contour.line_contour_group = plot.contour(2) slice_0.contour.contour_type = ContourType.Overlay # AKA "Both lines and flood" slice_0.show_primary_slice = False slice_0.show_start_and_end_slices = True slice_0.show_intermediate_slices = True slice_0.start_position = (-.21, .05, .025) slice_0.end_position = (1.342, .95, .475) slice_0.num_intermediate_slices = 3 # ensure consistent output between interactive (connected) and batch slice_0.contour.flood_contour_group.levels.reset_to_nice() slice_0.contour.line_contour_group.levels.reset_to_nice() tp.export.save_png('slice_contour.png', 600, supersample=3) .. figure:: /_static/images/slice_contour.png :width: 300px :figwidth: 300px """ def __init__(self, slice_group): super().__init__(slice_group, sv.CONTOUR) self.plot = slice_group.plot @property def show(self): """`bool`: Show contours on the slice. Example usage:: >>> plot.show_slices = True >>> plot.slice(1).contour.show = True """ return self._get_style(bool, sv.SHOW) @show.setter def show(self, value): self._set_style(bool(value), sv.SHOW) @property def contour_type(self): """`ContourType`: Contour type for the slice contours. Example usage:: >>> plot.show_slices = True >>> plot.slice(0).contour.contour_type = ContourType.AverageCell """ return self._get_style(ContourType, sv.CONTOURTYPE) @contour_type.setter def contour_type(self, value): self._set_style(ContourType(value), sv.CONTOURTYPE) @property def line_color(self): """`Color`: `Color` of contour lines. Selecting `Color.MultiColor` will color the slice contour lines based on the `contour group <tecplot.plot.ContourGroup>` variable. Example usage:: >>> plot.show_slices = True >>> plot.slice(0).contour.line_color = Color.Blue """ return self._get_style(Color, sv.COLOR) @line_color.setter def line_color(self, value): self._set_style(Color(value), sv.COLOR) @property def line_thickness(self): """`float`: Contour line thickness as a percentage of frame width. Suggested values are one of: **.02, .1, .4, .8, 1.5** Example usage:: >>> plot.show_slices = True >>> plot.slice(0).contour.line_thickness = .4 """ return self._get_style(float, sv.LINETHICKNESS) @line_thickness.setter def line_thickness(self, value): self._set_style(float(value), sv.LINETHICKNESS) @property def flood_contour_group_index(self): """`Index`: Zero-based `Index` of the flodding `ContourGroup`. This property sets and gets, by `Index`, the `ContourGroup` used for flooding. Changing style on this `ContourGroup` will affect all fieldmaps on the same `Frame <layout.Frame>` that use it. Example usage:: >>> plot.show_slices = True >>> contour = plot.slice(0).contour >>> contour.flood_contour_group_index = 1 """ return self._get_style(tecutil.Index, sv.FLOODCOLORING) @flood_contour_group_index.setter def flood_contour_group_index(self, index): self._set_style(tecutil.Index(index), sv.FLOODCOLORING) @property def flood_contour_group(self): """`ContourGroup`: Contour group to use for flooding. Changing style on this `ContourGroup` will affect all fieldmaps on the same `Frame <layout.Frame>` that use it. Example usage:: >>> group = plot.contour(1) >>> contour = plot.slice(1).contour >>> contour.flood_contour_group = group """ indices = self.flood_contour_group_index if isinstance(indices, Iterable): return tuple([self.plot.contour(i) for i in indices]) else: return self.plot.contour(indices) @flood_contour_group.setter def flood_contour_group(self, flood_contour_group): self.flood_contour_group_index = flood_contour_group.index @property def line_contour_group_index(self): """`int`: Zero-based `Index` of the `ContourGroup` for contour lines. This property sets and gets, by `Index`, the `ContourGroup` used for line placement. Although all properties of the `ContourGroup` can be manipulated through this object, many of them (i.e., color) will not affect the lines unless the `FieldmapContour.line_color` is set to the same `ContourGroup`. Note that changing style on this `ContourGroup` will affect all other fieldmaps on the same `Frame <layout.Frame>` that use it. Example usage:: >>> plot.show_slices = True >>> contour = plot.slice(0).contour >>> contour.line_contour_group_index = 2 """ return self._get_style(tecutil.Index, sv.LINECONTOURGROUP) @line_contour_group_index.setter def line_contour_group_index(self, index): self._set_style(tecutil.Index(index), sv.LINECONTOURGROUP) @property def line_contour_group(self): """`ContourGroup`: Contour group to use for contour lines. Changing style on this `ContourGroup` will affect all fieldmaps on the same `Frame <layout.Frame>` that use it. Example usage:: >>> group = plot.contour(1) >>> contour = plot.slice(1).contour >>> contour.line_contour_group = group """ indices = self.line_contour_group_index if isinstance(indices, Iterable): return tuple([self.plot.contour(i) for i in indices]) else: return self.plot.contour(indices) @line_contour_group.setter def line_contour_group(self, line_contour_group): self.line_contour_group_index = line_contour_group.index @property def use_lighting_effect(self): """`bool`; Enable lighting effect. .. note:: Setting `SliceContour.use_lighting_effect` will also set the same value for `SliceShade.use_lighting_effect`, and vice-versa. The lighting effect is set with `SliceEffects.lighting_effect`, and may be one of `LightingEffect.Gouraud` or `LightingEffect.Paneled`. Example usage:: >>> plot.show_slices = True >>> contour = plot.slice(0).contour >>> contour.use_lighting_effect = True >>> plot.slice(0).effects.lighting_effect = LightingEffect.Paneled """ return self._get_style(bool, sv.USELIGHTINGEFFECT) @use_lighting_effect.setter def use_lighting_effect(self, value): self._set_style(bool(value), sv.USELIGHTINGEFFECT)
[docs]class SliceGroupCollection(session.Style): """Change attributes associated with multiple slices. Slices can include lighting effects, contours, meshes, and more. To customize these and other attributes of slices, use this object. It controls the style for specific slice groups within a `Frame <layout.Frame>`. Slice `contour <SliceGroup.contour>`, vector, edge, effects, mesh, visibility and position information are accessed through this class: .. code-block:: python :emphasize-lines: 12-29 from os import path import tecplot as tp from tecplot.constant import * examples_dir = tp.session.tecplot_examples_directory() datafile = path.join(examples_dir, 'SimpleData', 'DuctFlow.plt') dataset = tp.data.load_tecplot(datafile) plot = tp.active_frame().plot() plot.contour(0).variable = dataset.variable('U(M/S)') plot.show_slices = True slices = plot.slices(0, 1, 2) slices.show = True slices.contour.show = True slices.contour.contour_type = ContourType.Overlay slices.effects.use_translucency = True slices.effects.surface_translucency = 70 # Show arbitrary slices slices.orientation = SliceSurface.Arbitrary slices.origin = (0.1, 0.2, 0) slices[0].arbitrary_normal = (1, 0.5, 0) slices[1].arbitrary_normal = (0.2, 1, 0) slices[2].arbitrary_normal = (0, 0, 1) slices.edge.show = True slices.edge.line_thickness = 0.4 plot.contour(0).levels.reset_to_nice() plot.contour(0).legend.show = False tp.export.save_png('slice_collection.png') .. figure:: /_static/images/slice_collection.png :width: 300px :figwidth: 300px Up to eight different slice groups can be set and each slice group can use different slice planes or different ranges for the same slice plane. This class behaves like `SliceGroup` except that setting any underlying style will do so for all of the represented slice groups. The style properties are then always returned as a `tuple` of properties, one for each group, ordered by index number. This means there is an asymmetry between setting and getting any property under this object, illustrated by the following example:: >>> slices = plot.slices(0, 1, 2) >>> slices.show = True >>> print(slices.show) (True, True, True) All examples that set style on a single slice like the following:: >>> plot.slice(0).contour.show = True may be converted to setting the same style on all slice groups like so:: >>> plot.slices().contour.show = True .. seealso:: `SliceGroup` .. versionadded:: 1.2 Slice collection objects. """ def __init__(self, plot, *indices): if __debug__: assert all(0 <= i < 8 for i in indices), \ 'Slice index out of range (must be in the range: [0,7])' if indices: self._indices = set([tecutil.Index(i) for i in indices]) else: self._indices = set(range(8)) self.plot = plot super().__init__(sv.SLICEATTRIBUTES, uniqueid=self.plot.frame.uid) @property def indices(self): return sorted(self._indices) def __getitem__(self, index): return SliceGroup(self.plot, self.indices[index]) def __iter__(self): self._current_index = -1 self._max_index = len(self._indices) return self def __next__(self): self._current_index += 1 if self._current_index < self._max_index: return self[self._current_index] raise StopIteration def __eq__(self, other): return (self.indices == other.indices) and (self.plot == other.plot) def __ne__(self, other): return not self.__eq__(other) def _get_style(self, rettype, *svargs, **kwargs): res = [] for index in self.indices: kwargs.update(**{sv.OFFSET1: index}) res.append(super()._get_style(rettype, *svargs, **kwargs)) return tuple(res) def _set_style(self, value, *svargs, **kwargs): for index in self.indices: kwargs.update(**{sv.OFFSET1: index}) super()._set_style(value, *svargs, **kwargs)
[docs] @tecutil.lock() def extract(self, mode=ExtractMode.SingleZone, assign_strand_ids=True, resulting_1d_zone_type=Resulting1DZoneType.IOrderedIfPossible, transient_mode=TransientOperationMode.SingleSolutionTime): """Create new zones from this slice collection. Extracts the current slices represented by this group to the `Dataset <data.Dataset>` as one or more zones. Parameters: mode (`ExtractMode`, optional): Determines how many zones are created upon extraction. Possible values are: `ExtractMode.SingleZone` (default) and `ExtractMode.OneZonePerConnectedRegion`. assign_strand_ids (`bool`, optional): Automatically assign strand ID's to the created zones. (default: `True`) resulting_1d_zone_type (`Resulting1DZoneType`, optional): The type of zone to create when the result is one-dimensional. Possible values are: `Resulting1DZoneType.IOrderedIfPossible` (default) and `Resulting1DZoneType.FELineSegment`. transient_mode (`TransientOperationMode`): Determines which solution times are used to extract slices when transient data is available in the dataset. Possible values are `TransientOperationMode.SingleSolutionTime` (default) or `TransientOperationMode.AllSolutionTimes`. Returns: generator_ of the extracted zones. .. seealso:: `tecplot.data.extract.extract_slice()` Example usage showing how to convert the resulting generator into a reusable list object of zones:: >>> slice_zones = list(plot.slices(0, 1).extract()) .. _generator: https://docs.python.org/3/reference/expressions.html#generator-expressions """ transient_mode = TransientOperationMode(transient_mode) dataset = self.plot.frame.dataset mode = ExtractMode(mode) nzones = dataset.num_zones with self.plot.frame.activated(), \ tecutil.ArgList() as arglist: arglist[sv.EXTRACTMODE] = mode arglist[sv.AUTOSTRANDTRANSIENTDATA] = bool(assign_strand_ids) zone_type = Resulting1DZoneType(resulting_1d_zone_type) arglist[sv.RESULTING1DZONETYPE] = zone_type if transient_mode != TransientOperationMode.SingleSolutionTime: arglist[sv.TRANSIENTOPERATIONMODE] = transient_mode with tecutil.IndexSet(*self._indices) as groups: arglist[sv.GROUPS] = groups if not _tecutil.ExtractSlicesX(arglist): raise TecplotSystemError() return (dataset.zone(i) for i in range(nzones, dataset.num_zones))
@property def vector(self): """`SliceVector`: Vector attributes for this slice group. Example usage:: >>> plot.slice(0).vector.show = True """ return SliceVector(self) @property def edge(self): """`SliceEdge`: Edge attributes for this slice group. Example usage:: >>> plot.slice(0).edge.show = True """ return SliceEdge(self) @property def effects(self): """`SliceEffects`: Effects attributes for this slice group. Example usage:: >>> plot.slice(0).effects.use_translucency = True """ return SliceEffects(self) @property def shade(self): """`SliceShade`: Shade attributes for this slice group. Example usage:: >>> plot.slice(0).shade.show = True """ return SliceShade(self) @property def mesh(self): """`SliceMesh`: Mesh attributes for this slice group. Example usage:: >>> plot.slice(0).mesh.show = True """ return SliceMesh(self) @property def show(self): """`bool`: Show slices for this slice group. Example usage:: >>> plot.slice(0).show = True """ return self._get_style(bool, sv.SHOWGROUP) @show.setter def show(self, value): self._set_style(bool(value), sv.SHOWGROUP) @property def show_primary_slice(self): """`bool`; Include the primary slice (first slice placed) in the `Plot`. Example usage:: >>> plot.slice(0).show = True >>> plot.slice(0).show_primary_slice = True """ return self._get_style(bool, sv.SHOWPRIMARYSLICE) @show_primary_slice.setter def show_primary_slice(self, value): self._set_style(bool(value), sv.SHOWPRIMARYSLICE) @property def contour(self): """`SliceContour`: Contour attributes for the slice group. Example usage:: >>> plot.slice(0).contour.show = True """ return SliceContour(self) @property def orientation(self): """`SliceSurface`: Select on which plane the slice is drawn. You may also choose `SliceSurface.Arbitrary` to place the slice on an arbitrary plane. To orient slices in an arbitrary direction, choose `SliceSurface.Arbitrary`. As with other slices, you may specify origin points for a primary slice and/or for start and end slices. Slices pass through the indicated origin point(s), so you can easily align the edge of a slice or group of slices along some other feature of the plot, such as an axis. If intermediate slices are activated, they are drawn equally spaced between the slices defined by the start and end origins. Example usage:: >>> plot.slice(0).orientation = SliceSurface.XPlanes """ return self._get_style(SliceSurface, sv.SLICESURFACE) @orientation.setter def orientation(self, value): self._set_style(SliceSurface(value), sv.SLICESURFACE) @property def arbitrary_normal(self): """`tuple`: Normal for arbitrary slices. Example usage:: >>> plot.slice(0).orientation = SliceSurface.Arbitrary >>> plot.slice(0).arbitrary_normal = (0.1, 0.2, 0.3) >>> plot.slice(0).arbitrary_normal.x 0.1 >>> plot.slice(0).arbitrary_normal.y 0.2 >>> plot.slice(0).arbitrary_normal.z 0.3 """ return session.XYZ(self, sv.NORMAL) @arbitrary_normal.setter def arbitrary_normal(self, values): session.XYZ(self, sv.NORMAL)[:] = values def _position(self, svarg): index_orientations = (SliceSurface.IPlanes, SliceSurface.JPlanes, SliceSurface.KPlanes) spatial = [o not in index_orientations for o in self.orientation] if all(spatial): return session.XYZ(self, svarg) elif any(spatial): msg = 'all slices must have the same type of orientation' raise TecplotLogicError(msg) else: return session.IndexIJK(self, svarg) @property def origin(self): """`tuple` or `int`: Origin of the slice. This will be a 3-`tuple` of `float` if `orientation` is ``X,Y,Z`` or zero-based `int` if `orientation` is ``I,J,K``. For arbitrary slice orientation, the origin can be any location. For axis orientations (`XPlanes`, `YPlanes`, etc.) two of the three components are not used. Example usage:: >>> slice_0 = plot.slice(0) >>> slice_0.orientation = SliceSurface.IPlanes >>> slice_0.origin = (1, 0, 0) >>> dx = (1, 1, 1) >>> slice_0.origin += dx >>> slice_0.origin.i 2 >>> slice_0.origin.j 1 >>> slice_0.origin.k 1 >>> slice_0.orientation = SliceSurface.Arbitrary >>> slice_0.origin = (.5, .1, .1) >>> slice_0.origin += dx >>> slice_0.origin.x 1.5 >>> slice_0.origin.y .1 >>> slice_0.origin.z .1 """ return self._position(sv.PRIMARYPOSITION) @origin.setter def origin(self, values): self._position(sv.PRIMARYPOSITION)[:] = values @property def end_position(self): """`tuple` or `int`: Position of the end slice. `SliceGroup.show_start_and_end_slices` must be `True` to show the end slice. This will be a 3-`tuple` of `float` if `orientation` is ``X,Y,Z`` or zero-based `int` if `orientation` is ``I,J,K``. Example usage:: >>> plot.slice(0).show_start_and_end_slices = True >>> plot.slice(0).end_position = (1, 1, 1) >>> plot.slice(0).end_position.i 1 """ return self._position(sv.ENDPOSITION) @end_position.setter def end_position(self, values): self._position(sv.ENDPOSITION)[:] = values @property def start_position(self): """`tuple` or `int`: Position of the start slice. `SliceGroup.show_start_and_end_slices` must be `True` to show the start slice. This will be a 3-`tuple` of `float` if `orientation` is ``X,Y,Z`` or zero-based `int` if `orientation` is ``I,J,K``. Example usage:: >>> plot.slice(0).show_start_and_end_slices = True >>> plot.slice(0).start_position = (1, 1, 1) >>> plot.slice(0).start_position.i 1 """ return self._position(sv.STARTPOSITION) @start_position.setter def start_position(self, values): self._position(sv.STARTPOSITION)[:] = values @property def num_intermediate_slices(self): """`int`: Number of intermediate slicing planes. You may specify between 1 and 5,000 intermediate slices. Example usage:: >>> # Show 2 intermediate slices >>> plot.slice(0).num_intermediate_slices = 2 """ return self._get_style(int, sv.NUMINTERMEDIATESLICES) @num_intermediate_slices.setter def num_intermediate_slices(self, value): self._set_style(int(value), sv.NUMINTERMEDIATESLICES) @property def show_intermediate_slices(self): """Show intermediate slices. Intermediate slices are evenly distributed between the start and end slices. Example usage:: >>> plot.slice(0).show_intermediate_slices = True """ return self._get_style(bool, sv.SHOWINTERMEDIATESLICES) @show_intermediate_slices.setter def show_intermediate_slices(self, value): self._set_style(bool(value), sv.SHOWINTERMEDIATESLICES) @property def obey_source_zone_blanking(self): """`bool`: Obey source zone blanking. When set to `True`, slices are subject to any blanking used for the data. When set to `False`, slices are generated for blanked and unblanked regions. Example usage:: >>> plot.slice(0).obey_source_zone_blanking = True """ return self._get_style(bool, sv.OBEYSOURCEZONEBLANKING) @obey_source_zone_blanking.setter def obey_source_zone_blanking(self, value): self._set_style(bool(value), sv.OBEYSOURCEZONEBLANKING) @property def slice_source(self): """`SliceSource`: `Zones <data_access>` to slice through. Choose to slice through volume `Zones <data_access>`, surface `Zones <data_access>`, or the surfaces of volume `Zones <data_access>`. Example usage:: >>> plot.slice(0).slice_source = SliceSource.SurfaceZones """ return self._get_style(SliceSource, sv.SLICESOURCE) @slice_source.setter def slice_source(self, value): self._set_style(SliceSource(value), sv.SLICESOURCE) @property def show_start_and_end_slices(self): """`bool`: Include start and end slices. Example usage:: >>> plot.slice(0).show_start_and_end_slices = True """ return self._get_style(bool, sv.SHOWSTARTENDSLICE) @show_start_and_end_slices.setter def show_start_and_end_slices(self, value): self._set_style(bool(value), sv.SHOWSTARTENDSLICE) @property def surface_generation_method(self): """`SurfaceGenerationMethod`: Determines how the surface is generated. May be one of: * `SurfaceGenerationMethod.Auto`: Selects one of the surface generation algorithms best suited for the zones participating in the slice generation. "All polygons" is used if one or more of the participating zones is polytope, otherwise "allow quads" is used. * `SurfaceGenerationMethod.AllPolygons`: Similar to the "All triangles" method except that all interior faces generated as a result of triangulation that are not part of the original mesh are eliminated. This preserves the original mesh of the source zones on the resulting slice. * `SurfaceGenerationMethod.AllTriangles`: An advanced algorithm that can handle complex saddle issues and guarantees that there will be no holes in the final surface. As the surface is composed entirely of triangles, it can be delivered more efficiently to the graphics hardware. * `SurfaceGenerationMethod.AllowQuads`: Produces quads or triangles, and the resulting surface more closely resembles the shape of the volume cells from the source zone. Since the quads are not arbitrarily divided into triangles, no biases are introduced, and the resulting surface may appear smoother. This method is preferred when the source zone is FE-Brick or IJK-Ordered and the surface is aligned with the source cells. Example usage:: >>> from tecplot.constant import SurfaceGenerationMethod >>> plot.slice(0).surface_generation_method = \\ ... SurfaceGenerationMethod.AllowQuads """ return self._get_style(SurfaceGenerationMethod, sv.SURFACEGENERATIONMETHOD) @surface_generation_method.setter def surface_generation_method(self, value): self._set_style(SurfaceGenerationMethod(value), sv.SURFACEGENERATIONMETHOD) @property def clip(self): """`ClipPlane`: Orientation of data clipping for this slice group. Clipping the field data, isosurfaces, streamtraces or other plot objects using slices requires setting the ``clip`` property of the slice as well as adding the slice group to the ``clip_planes`` property on the fieldmap effects. Only slice groups 0 to 5 are available for clipping in this framework:: >>> from tecplot.constant import * >>> # setup slice and clipping orientation >>> slice = plot.slice(0) >>> slice.origin = (7, 0, 0) >>> slice.clip = ClipPlane.AbovePrimarySlice >>> # add slice group to the fieldmap clip planes >>> plot.fieldmap(0).effects.clip_planes = [slice] >>> # turn on and set value of isosurface >>> # and enforce slice clipping >>> isosurf = plot.isosurface(0) >>> isosurf.isosurface_values = 3 >>> isosurf.use_slice_clipping = True >>> # turn on isosurfaces and slices >>> pt.show_isosurfaces = True >>> pt.show_slices = True .. warning:: **Slice clipping is only supported for X, Y and Z-planes.** Slice clipping has no effect for slices that have an orientation of `SliceSurface.Arbitrary`, `SliceSurface.IPlanes`, `SliceSurface.JPlanes` or , `SliceSurface.KPlanes`. That is, the orientation must be one of: `SliceSurface.XPlanes`, `SliceSurface.YPlanes` or `SliceSurface.ZPlanes`. """ return self._get_style(ClipPlane, sv.CLIPPLANE) @clip.setter def clip(self, value): self._set_style(ClipPlane(value), sv.CLIPPLANE) @property def use_slice_clipping(self): """`bool`: Clip this slice by any intersecting slices. Example usage:: >>> from tecplot.constant import ClipPlane >>> slice = plot.slice(0) >>> slice.clip = ClipPlane.AbovePrimarySlice >>> plot.fieldmap(0).effects.clip_planes = slice >>> plot.slice(1).use_slice_clipping = True .. seealso:: `SliceGroup.clip` """ return self._get_style(bool, sv.OBEYCLIPPLANES) @use_slice_clipping.setter def use_slice_clipping(self, value): self._set_style(bool(value), sv.OBEYCLIPPLANES)
[docs]class SliceGroup(SliceGroupCollection): """Change attributes associated with a specific slice group. Slices can include lighting effects, contours, meshes, and more. To customize these and other attributes of slices, use this object. This object controls the style for a specific slice group within a `Frame <layout.Frame>`. Slice `contour <SliceGroup.contour>`, vector, edge, effects, mesh, visibility and position information are accessed through this class: .. code-block:: python :emphasize-lines: 19-40 from os import path import tecplot as tp from tecplot.constant import * examples_dir = tp.session.tecplot_examples_directory() datafile = path.join(examples_dir, 'SimpleData', 'DuctFlow.plt') dataset = tp.data.load_tecplot(datafile) plot = tp.active_frame().plot() plot.contour(0).variable = dataset.variable('U(M/S)') plot.show_edge = True plot.fieldmap(0).edge.edge_type = EdgeType.Creases vectors = plot.vector vectors.u_variable = dataset.variable('U(M/S)') vectors.v_variable = dataset.variable('V(M/S)') vectors.w_variable = dataset.variable('W(M/S)') plot.show_slices = True slice_0 = plot.slice(0) slice_0.contour.show = True slice_0.contour.contour_type = ContourType.Overlay # AKA "Both lines and flood" slice_0.effects.use_translucency = True slice_0.effects.surface_translucency = 30 # Show an arbitrary slice slice_0.orientation = SliceSurface.Arbitrary slice_0.arbitrary_normal = (1, .5, 0) slice_0.show_primary_slice = False slice_0.show_start_and_end_slices = True slice_0.start_position = (-.21, .05, .025) slice_0.end_position = (1.342, .95, .475) slice_0.show_intermediate_slices = True slice_0.num_intermediate_slices = 3 slice_0.edge.show = True slice_0.edge.line_thickness = 0.4 # ensure consistent output between interactive (connected) and batch plot.contour(0).levels.reset_to_nice() tp.export.save_png('slice_group.png', 600, supersample=3) .. figure:: /_static/images/slice_group.png :width: 300px :figwidth: 300px Up to eight different slice groups can be set. Each slice group can use different slice planes or different ranges for the same slice plane. >>> slice_3 = plot.slice(3) >>> slice_3.contour.show = True .. seealso:: `SliceGroupCollection` """ def __init__(self, plot, index): self.index = index super().__init__(plot, index) def _get_style(self, rettype, *svargs, **kwargs): return super()._get_style(rettype, *svargs, **kwargs)[0] def _position(self, svarg): if self.orientation in (SliceSurface.IPlanes, SliceSurface.JPlanes, SliceSurface.KPlanes): return session.IndexIJK(self, svarg) else: return session.XYZ(self, svarg)
[docs] @tecutil.lock() def set_arbitrary_from_points(self, p1, p2, p3): """Set an arbitrary slice from 3 points. Set the normal and origin of an arbitrary slice using three points. The origin will be set to the 3rd point. The three points must not be coincident or collinear. The slice's origin is set to the third point and its normal is recalculated such that the cutting plane passes through all three points. Parameters: p1: 3-`tuple` of floats ``(x, y, z)`` p2: 3-`tuple` of floats ``(x, y, z)`` p3: 3-`tuple` of floats ``(x, y, z)`` Example usage:: >>> slice0 = plot.slice(0) >>> slice0.set_arbitrary_from_points((0.0, 0.0, 0.0), ... (0.1, 0.2, 0.3), ... (0.1, 0.1, 0.1)) """ uid = self._style_attrs[sv.UNIQUEID] points = list(it.chain(p1, p2, p3)) if not _tecutil.SliceSetArbitraryUsingThreePoints( uid, self.index + 1, *points): msg = 'Error creating arbitrary slice from three points' raise TecplotSystemError(msg)
[docs] def extract(self, mode=ExtractMode.SingleZone, assign_strand_ids=True, resulting_1d_zone_type=Resulting1DZoneType.IOrderedIfPossible, transient_mode=TransientOperationMode.SingleSolutionTime): """Create new zones from this slice. Extracts the current slices represented by this group to the `Dataset <data.Dataset>` as one or more zones. Parameters: mode (`ExtractMode`, optional): Determines how many zones are created upon extraction. Possible values are: `ExtractMode.SingleZone` (default) and `ExtractMode.OneZonePerConnectedRegion`. assign_strand_ids (`bool`, optional): Automatically assign strand ID's to the created zones. (default: `True`) resulting_1d_zone_type (`Resulting1DZoneType`, optional): The type of zone to create when the result is one-dimensional. Possible values are: `Resulting1DZoneType.IOrderedIfPossible` (default) and `Resulting1DZoneType.FELineSegment`. transient_mode (`TransientOperationMode`): Determines which solution times are used to extract slices when transient data is available in the dataset. Possible values are `TransientOperationMode.SingleSolutionTime` (default) or `TransientOperationMode.AllSolutionTimes`. Returns: The extracted zone is returned if **mode** is `ExtractMode.SingleZone` and **transient_mode** is `TransientOperationMode.SingleSolutionTime`, otherwise a generator_ of the extracted zones. .. seealso:: `tecplot.data.extract.extract_slice()` Example usage:: >>> slice_zone = plot.slice(0).extract() """ result = super().extract(mode, assign_strand_ids, resulting_1d_zone_type, transient_mode) if ( mode == ExtractMode.SingleZone and transient_mode == TransientOperationMode.SingleSolutionTime ): return list(result)[0] else: return result