pytecplot 1.5.2__py3-none-any.whl

tecplot/plot/rgb_coloring.py

@@ -0,0 +1,281 @@
+from builtins import super
+
+from ..constant import *
+from ..exception import *
+from ..tecutil import _tecutil_connector, sv
+from .. import legend, session, tecutil, version
+
+
+class RGBColoring(session.Style):
+    """RGB coloring (multivariate contour) style control.
+
+    .. code-block:: python
+        :emphasize-lines: 39-53
+
+        import os
+        import numpy as np
+
+        import tecplot as tp
+        from tecplot.constant import *
+
+
+        def normalize_variable(dataset, varname, nsigma=2):
+            '''
+            Normalize a variable such that the specified number of standard deviations
+            are within the range [0.5, 1] and the mean is transformed to 0.5. The
+            new variable will append " normalized" to the original variable's name.
+            '''
+            with tp.session.suspend():
+                newvarname = varname + ' normalized'
+                dataset.add_variable(newvarname)
+                data = np.concatenate([z.values(varname).as_numpy_array()
+                                       for z in dataset.zones()])
+                vmin = data.mean() - nsigma * data.std()
+                vmax = data.mean() + nsigma * data.std()
+                for z in dataset.zones():
+                    arr = z.values(varname).as_numpy_array()
+                    z.values(newvarname)[:] = (arr - vmin) / (vmax - vmin)
+
+
+        examples_dir = tp.session.tecplot_examples_directory()
+        infile = os.path.join(examples_dir, 'SimpleData', 'HeatExchanger.plt')
+        dataset = tp.data.load_tecplot(infile)
+
+        frame = tp.active_frame()
+        plot = frame.plot(PlotType.Cartesian2D)
+        plot.show_contour = True
+
+        # Variables must be normalized relative to each other
+        # to make effective use of RGB coloring.
+        normalize_variable(dataset, 'T(K)')
+        normalize_variable(dataset, 'P(N)')
+
+        plot.rgb_coloring.mode = RGBMode.SpecifyGB
+
+        # all three channel variables must be set even if
+        # we are only contouring on two of them.
+        plot.rgb_coloring.red_variable = dataset.variable(0)
+        plot.rgb_coloring.green_variable = dataset.variable('P(N) normalized')
+        plot.rgb_coloring.blue_variable = dataset.variable('T(K) normalized')
+
+        plot.rgb_coloring.legend.show = True
+        plot.rgb_coloring.legend.use_variable_for_green_label = False
+        plot.rgb_coloring.legend.green_label = 'Pressure'
+        plot.rgb_coloring.legend.use_variable_for_blue_label = False
+        plot.rgb_coloring.legend.blue_label = 'Temperature'
+
+        plot.fieldmaps().contour.flood_contour_group = plot.rgb_coloring
+
+        tp.export.save_png('rgb_coloring.png')
+
+    .. figure:: /_static/images/rgb_coloring.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    def __init__(self, plot):
+        self.plot = plot
+        super().__init__(sv.GLOBALRGB, **plot._kw)
+
+    def __eq__(self, other):
+        return self.plot == other.plot
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    @property
+    def index(self):
+        """`Index`: Color `Index` for RGB Coloring.
+
+        This property is used internally to identify it as a contour flooding
+        option.
+        """
+        return tecutil.Index(Color.RGBColor.value)
+
+    @property
+    def legend(self):
+        """`RGBColoringLegend`: Legend placement and style control.
+
+        Example usage::
+
+            >>> plot.rgb_coloring.legend.show = True
+        """
+        return legend.RGBColoringLegend(self)
+
+    @property
+    def mode(self):
+        """`RGBMode`: Which channels to use for RGB coloring.
+
+        Example usage::
+
+            >>> from tecplot.constant import RGBMode
+            >>> plot.rgb_coloring.mode = RGBMode.SpecifyRB
+        """
+        return self._get_style(RGBMode, sv.RGBMODE)
+
+    @mode.setter
+    def mode(self, value):
+        self._set_style(RGBMode(value), sv.RGBMODE)
+
+    @property
+    def min_intensity(self):
+        """`float`: `Variable` value at minimum intensity for each channel.
+
+        This should typically be set to the minimum value of the data being
+        plotted::
+
+            >>> plot.rgb_coloring.min_intensity = dataset.variable('P').min()
+        """
+        return self._get_style(float, sv.RANGEMIN)
+
+    @min_intensity.setter
+    def min_intensity(self, value):
+        self._set_style(float(value), sv.RANGEMIN)
+
+    @property
+    def max_intensity(self):
+        """`float`: `Variable` value at maximum intensity for each channel.
+
+        This should typically be set to the maximum value of the data being
+        plotted::
+
+            >>> plot.rgb_coloring.max_intensity = dataset.variable('P').max()
+        """
+        return self._get_style(float, sv.RANGEMAX)
+
+    @max_intensity.setter
+    def max_intensity(self, value):
+        self._set_style(float(value), sv.RANGEMAX)
+
+    def _ensure_valid_rgb_variables(self, index):
+        """
+            Note: this is essentially a work-around for behavior in the Tecplot
+            engine where setting a single RGB channel would be reverted when
+            the engine goes to an on-idle state. The engine was changed to
+            allow setting a single channel in 2018 R3 but this function remains
+            so that setting RGB channel variables still work with 2018 R2.
+            However, it requires the suspend context which was not available
+            in 2018 R1.
+        """
+        if _tecutil_connector.connected:
+            r = self.red_variable_index
+            g = self.green_variable_index
+            b = self.blue_variable_index
+            if any(x < 0 for x in (r, g, b)):
+                r = tecutil.Index(index if r < 0 else r)
+                g = tecutil.Index(index if g < 0 else g)
+                b = tecutil.Index(index if b < 0 else b)
+                with session.suspend():
+                    self._set_style(r, sv.REDCHANNELVAR)
+                    self._set_style(g, sv.GREENCHANNELVAR)
+                    self._set_style(b, sv.BLUECHANNELVAR)
+
+    @property
+    def red_variable_index(self):
+        """`Index`: `Variable` `Index` to use for the red channel.
+
+        Example usage::
+
+            >>> plot.rgb_coloring.red_variable_index = 5
+
+        .. note::
+            In connected mode, setting this property requires Tecplot 360
+            version 2018 R2 or later.
+        """
+        return self._get_style(tecutil.Index, sv.REDCHANNELVAR)
+
+    @red_variable_index.setter
+    def red_variable_index(self, value):
+        self._ensure_valid_rgb_variables(value)
+        self._set_style(tecutil.Index(value), sv.REDCHANNELVAR)
+
+    @property
+    def red_variable(self):
+        """`Variable`: `Variable` to use for the red channel.
+
+        Example usage::
+
+            >>> plot.rgb_coloring.red_variable = dataset.variable('Gas')
+
+        .. note::
+            In connected mode, setting this property requires Tecplot 360
+            version 2018 R2 or later.
+        """
+        return self.plot.frame.dataset.variable(self.red_variable_index)
+
+    @red_variable.setter
+    def red_variable(self, variable):
+        self.red_variable_index = variable.index
+
+    @property
+    def green_variable_index(self):
+        """`Index`: `Variable` `Index` to use for the green channel.
+
+        Example usage::
+
+            >>> plot.rgb_coloring.green_variable_index = 3
+
+        .. note::
+            In connected mode, setting this property requires Tecplot 360
+            version 2018 R2 or later.
+        """
+        return self._get_style(tecutil.Index, sv.GREENCHANNELVAR)
+
+    @green_variable_index.setter
+    def green_variable_index(self, value):
+        self._ensure_valid_rgb_variables(value)
+        self._set_style(tecutil.Index(value), sv.GREENCHANNELVAR)
+
+    @property
+    def green_variable(self):
+        """`Variable`: `Variable` to use for the green channel.
+
+        Example usage::
+
+            >>> plot.rgb_coloring.green_variable = dataset.variable('Oil')
+
+        .. note::
+            In connected mode, setting this property requires Tecplot 360
+            version 2018 R2 or later.
+        """
+        return self.plot.frame.dataset.variable(self.green_variable_index)
+
+    @green_variable.setter
+    def green_variable(self, variable):
+        self.green_variable_index = variable.index
+
+    @property
+    def blue_variable_index(self):
+        """`Index`: `Variable` `Index` to use for the blue channel.
+
+        Example usage::
+
+            >>> plot.rgb_coloring.blue_variable_index = 4
+
+        .. note::
+            In connected mode, setting this property requires Tecplot 360
+            version 2018 R2 or later.
+        """
+        return self._get_style(tecutil.Index, sv.BLUECHANNELVAR)
+
+    @blue_variable_index.setter
+    def blue_variable_index(self, value):
+        self._ensure_valid_rgb_variables(value)
+        self._set_style(tecutil.Index(value), sv.BLUECHANNELVAR)
+
+    @property
+    def blue_variable(self):
+        """`Variable`: `Variable` to use for the blue channel.
+
+        Example usage::
+
+            >>> plot.rgb_coloring.blue_variable = dataset.variable('Water')
+
+        .. note::
+            In connected mode, setting this property requires Tecplot 360
+            version 2018 R2 or later.
+        """
+        return self.plot.frame.dataset.variable(self.blue_variable_index)
+
+    @blue_variable.setter
+    def blue_variable(self, variable):
+        self.blue_variable_index = variable.index

tecplot/plot/scatter.py

@@ -0,0 +1,396 @@
+from builtins import str, super
+
+from ..constant import *
+from ..exception import *
+from ..tecutil import sv
+from .. import legend, session, tecutil, text
+from . import labels, symbol
+
+
+class PieChartsWedge(session.Style):
+    """Individual wedge style control for pie charts.
+
+    .. seealso:: `PieCharts`
+    """
+    def __init__(self, pie_charts, index):
+        self.pie_charts = pie_charts
+        self.index = tecutil.Index(index)
+        self.plot = pie_charts.scatter.plot
+        super().__init__(pie_charts._sv, sv.WEDGE, offset1=self.index,
+                         **pie_charts._kw)
+
+    @property
+    def show(self):
+        """`bool`
+
+        .. note::
+
+            At least one fieldmap must have scatter symbol shape set
+            to `GeomShape.PieChart` before setting the show property
+            of the wedges to `True`::
+
+                from tecplot.constant import GeomShape
+                plot.fieldmap(0).scatter.symbol().shape = GeomShape.PieChart
+                plot.scatter.pie_charts.wedge(0).show = True
+        """
+        return self._get_style(bool, sv.INCLUDE)
+
+    @show.setter
+    def show(self, value):
+        self._set_style(bool(value), sv.INCLUDE)
+
+    @property
+    def show_label(self):
+        """`bool`"""
+        return self._get_style(bool, sv.SHOWLABEL)
+
+    @show_label.setter
+    def show_label(self, value):
+        self._set_style(bool(value), sv.SHOWLABEL)
+
+    @property
+    def label_text(self):
+        """`str`"""
+        return self._get_style(str, sv.LABELTEXT)
+
+    @label_text.setter
+    def label_text(self, value):
+        self._set_style(str(value), sv.LABELTEXT)
+
+    @property
+    def color(self):
+        """`Color`"""
+        return self._get_style(Color, sv.COLOR)
+
+    @color.setter
+    def color(self, value):
+        self._set_style(Color(value), sv.COLOR)
+
+    @property
+    def variable_index(self):
+        """`Index`"""
+        return self._get_style(tecutil.Index, sv.VAR)
+
+    @variable_index.setter
+    def variable_index(self, value):
+        self._set_style(tecutil.Index(value), sv.VAR)
+
+    @property
+    def variable(self):
+        """`Variable`"""
+        return self.plot.frame.dataset.variable(self.variable_index)
+
+    @variable.setter
+    def variable(self, variable):
+        self.variable_index = variable.index
+
+
+class PieCharts(session.Style):
+    """Pie charts displayed at each scatter point.
+
+    .. code-block:: python
+        :emphasize-lines: 46-59
+
+        import os
+        import numpy as np
+
+        import tecplot as tp
+        from tecplot.constant import *
+
+
+        def normalize_variable(dataset, varname, nsigma=2):
+            '''
+            Normalize a variable such that the specified number of standard deviations
+            are within the range [0.5, 1] and the mean is transformed to 0.5. The
+            new variable will append " normalized" to the original variable's name.
+            '''
+            with tp.session.suspend():
+                newvarname = varname + ' normalized'
+                dataset.add_variable(newvarname)
+                data = np.concatenate([z.values(varname).as_numpy_array()
+                                       for z in dataset.zones()])
+                vmin = data.mean() - nsigma * data.std()
+                vmax = data.mean() + nsigma * data.std()
+                for z in dataset.zones():
+                    arr = z.values(varname).as_numpy_array()
+                    z.values(newvarname)[:] = (arr - vmin) / (vmax - vmin)
+
+
+        examples_dir = tp.session.tecplot_examples_directory()
+        infile = os.path.join(examples_dir, 'SimpleData', 'HeatExchanger.plt')
+        dataset = tp.data.load_tecplot(infile)
+
+        frame = tp.active_frame()
+        plot = frame.plot(PlotType.Cartesian2D)
+        plot.show_scatter = True
+
+        plot.axes.x_axis.min = 6
+        plot.axes.x_axis.max = 8
+        plot.axes.y_axis.min = 1.5
+        plot.axes.y_axis.max = 3.0
+
+        # Normalize variables to the range [0, 1]
+        normalize_variable(dataset, 'T(K)')
+        normalize_variable(dataset, 'P(N)')
+
+        frame.add_text(r'Normalized Temperature in Red', (50, 95), color=Color.Red)
+        frame.add_text(r'Normalized Pressure in Blue', (50, 92), color=Color.Blue)
+
+        fmaps = plot.fieldmaps()
+        fmaps.scatter.symbol().shape = GeomShape.PieChart
+        fmaps.scatter.size = 4.0
+
+        pie_charts = plot.scatter.pie_charts
+        pie_charts.wedge(0).show = True
+        pie_charts.wedge(0).show_label = False
+        pie_charts.wedge(0).variable = dataset.variable('T(K) normalized')
+        pie_charts.wedge(0).color = Color.Red
+
+        pie_charts.wedge(1).show = True
+        pie_charts.wedge(1).show_label = False
+        pie_charts.wedge(1).variable = dataset.variable('P(N) normalized')
+        pie_charts.wedge(1).color = Color.Blue
+
+        tp.export.save_png('pie_charts.png')
+
+    .. figure:: /_static/images/pie_charts.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    def __init__(self, scatter):
+        self.scatter = scatter
+        super().__init__(scatter._sv, sv.PIECHARTS, **scatter._kw)
+
+    @property
+    def label_offset(self):
+        """`float`"""
+        return self._get_style(float, sv.LABELOFFSET)
+
+    @label_offset.setter
+    def label_offset(self, value):
+        self._set_style(float(value), sv.LABELOFFSET)
+
+    @property
+    def label_text(self):
+        """`str`"""
+        return self._get_style(str, sv.LABELTEXT)
+
+    @label_text.setter
+    def label_text(self, value):
+        self._set_style(str(value), sv.LABELTEXT)
+
+    @property
+    def label_color(self):
+        """`Color`"""
+        return self._get_style(Color, sv.LABELTEXTCOLOR)
+
+    @label_color.setter
+    def label_color(self, value):
+        self._set_style(Color(value), sv.LABELTEXTCOLOR)
+
+    @property
+    def label_font(self):
+        """`text.Font`"""
+        return text.Font(self, sv.LABELTEXTSHAPE)
+
+    @property
+    def show_zero_value_wedge_labels(self):
+        """`bool`"""
+        return self._get_style(bool, sv.SHOWLABELFORZEROVALUEWEDGES)
+
+    @show_zero_value_wedge_labels.setter
+    def show_zero_value_wedge_labels(self, value):
+        self._set_style(bool(value), sv.SHOWLABELFORZEROVALUEWEDGES)
+
+    @property
+    def start_angle(self):
+        """`float`"""
+        return self._get_style(float, sv.STARTANGLE)
+
+    @start_angle.setter
+    def start_angle(self, value):
+        self._set_style(float(value), sv.STARTANGLE)
+
+    def wedge(self, index):
+        """`PieChartsWedge`"""
+        return PieChartsWedge(self, index)
+
+
+class Scatter(session.Style):
+    """Plot-local scatter style settings.
+
+    This class controls the style of drawn scatter points on a specific plot.
+
+    .. code-block:: python
+        :emphasize-lines: 15
+
+        from os import path
+        import tecplot as tp
+        from tecplot.constant import *
+
+        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()
+        frame.plot_type = PlotType.Cartesian2D
+        plot = frame.plot()
+        plot.contour(0).variable = dataset.variable('T(K)')
+        plot.show_scatter = True
+
+        plot.scatter.variable = dataset.variable('P(N)')
+
+        for z in dataset.zones():
+            scatter = plot.fieldmap(z).scatter
+            scatter.symbol_type = SymbolType.Geometry
+            scatter.symbol().shape = GeomShape.Circle
+            scatter.fill_mode = FillMode.UseSpecificColor
+            scatter.fill_color = plot.contour(0)
+            scatter.color = plot.contour(0)
+            scatter.size_by_variable = True
+
+        frame.add_text('Size of dots indicate relative pressure', (20, 80))
+
+        # ensure consistent output between interactive (connected) and batch
+        plot.contour(0).levels.reset_to_nice()
+
+        tp.export.save_png('scatter.png')
+
+    .. figure:: /_static/images/scatter.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    def __init__(self, plot):
+        self.plot = plot
+        super().__init__(sv.GLOBALSCATTER, uniqueid=self.plot.frame.uid)
+
+    @property
+    def base_font(self):
+        """`BaseFont`: Default typeface to use for text scatter symbols.
+
+        Example usage::
+
+            >>> plot.scatter.base_font.typeface = 'Times'
+        """
+        return text.BaseFont(*self._sv, **self._kw)
+
+    @property
+    def legend(self):
+        """`ScatterLegend`: Scatter symbol legend.
+
+        Example usage::
+
+            >>> plot.scatter.legend.show = True
+        """
+        return legend.ScatterLegend(self)
+
+    @property
+    def pie_charts(self):
+        return PieCharts(self)
+
+    @property
+    def reference_symbol(self):
+        """`ScatterReferenceSymbol`: Reference symbol for scatter plots.
+
+        The reference scatter symbol is only shown when the scatter symbols are
+        sized by a `Variable` in the `Dataset <data.Dataset>`. Example::
+
+            >>> plot.fieldmap(0).scatter.size_by_variable = True
+            >>> plot.scatter.variable = dataset.variable('s')
+            >>> plot.scatter.reference_symbol.show = True
+        """
+        return symbol.ScatterReferenceSymbol(self)
+
+    @property
+    def relative_size(self):
+        """`float`: Relative size of the reference symbol.
+
+        Relative size will be in ``cm`` when units are set to
+        `RelativeSizeUnits.Page`. Example usage::
+
+            >>> plot.scatter.relative_size = 20
+        """
+        return self._get_style(float, sv.RELATIVESIZE)
+
+    @relative_size.setter
+    def relative_size(self, value):
+        self._set_style(float(value), sv.RELATIVESIZE)
+
+    @property
+    def relative_size_units(self):
+        """`RelativeSizeUnits`: Use grid or page units for relative size.
+
+        Relative size will be in ``cm`` when units are set to
+        `RelativeSizeUnits.Page`. Example usage::
+
+            >>> from tecplot.constant import RelativeSizeUnits
+            >>> plot.scatter.relative_size_units = RelativeSizeUnits.Grid
+            >>> plot.scatter.relative_size = 2.0
+        """
+        if self._get_style(bool, sv.RELATIVESIZEINGRIDUNITS):
+            return RelativeSizeUnits.Grid
+        else:
+            return RelativeSizeUnits.Page
+
+    @relative_size_units.setter
+    def relative_size_units(self, value):
+        value = RelativeSizeUnits(value) == RelativeSizeUnits.Grid
+        self._set_style(value, sv.RELATIVESIZEINGRIDUNITS)
+
+    @property
+    def sphere_render_quality(self):
+        """`SphereScatterRenderQuality`: render quality of spheres
+
+        Example usage::
+
+            >>> from tecplot.constant import *
+            >>> plot.fieldmap(0).scatter.symbol().shape = GeomShape.Sphere
+            >>> scatter = plot.scatter
+            >>> scatter.sphere_render_quality = SphereScatterRenderQuality.Low
+        """
+        return self._get_style(SphereScatterRenderQuality,
+                               sv.SPHERESCATTERRENDERQUALITY)
+
+    @sphere_render_quality.setter
+    def sphere_render_quality(self, value):
+        self._set_style(SphereScatterRenderQuality(value),
+                        sv.SPHERESCATTERRENDERQUALITY)
+
+    @property
+    def variable_index(self):
+        """Zero-based index of the `Variable` used for size of scatter symbols.
+
+        .. code-block:: python
+
+            >>> plot.scatter.variable_index = dataset.variable('P').index
+            >>> plot.fieldmap(0).scatter.size_by_variable = True
+
+        The `Dataset <data.Dataset>` attached to this contour group's `Frame <layout.Frame>` is used, and
+        the variable itself can be obtained through it::
+
+            >>> scatter = plot.scatter
+            >>> scatter_var = dataset.variable(scatter.variable_index)
+            >>> scatter_var.index == scatter.variable_index
+            True
+        """
+        return self._get_style(tecutil.Index, sv.VAR)
+
+    @variable_index.setter
+    def variable_index(self, index):
+        self._set_style(tecutil.Index(index), sv.VAR)
+
+    @property
+    def variable(self):
+        """The `Variable` to be used when sizing scatter symbols.
+
+        The variable must belong to the `Dataset <data.Dataset>` attached to the `Frame <layout.Frame>`
+        that holds this `ContourGroup`. Example usage::
+
+            >>> plot.scatter.variable = dataset.variable('P')
+            >>> plot.fieldmap(0).scatter.size_by_variable = True
+        """
+        return self.plot.frame.dataset.variable(self.variable_index)
+
+    @variable.setter
+    def variable(self, variable):
+        self.variable_index = variable.index