pytecplot 1.5.2__py3-none-any.whl

tecplot/plot/axes.py

@@ -0,0 +1,881 @@
+from builtins import super
+
+from collections import namedtuple
+
+from ..tecutil import _tecutil
+from ..constant import *
+from ..exception import *
+from .. import session, tecutil
+from ..tecutil import (inherited_property, flatten_args, lock, lock_attributes,
+                       sv)
+from .axis import (Cartesian2DFieldAxis, Cartesian3DFieldAxis,
+                   PolarAngleLineAxis, RadialLineAxis, SketchAxis, XYLineAxis)
+from .grid import (Cartesian2DGridArea, Cartesian3DGridArea, GridArea,
+                   PreciseGrid)
+from .view import Cartesian2DViewport, PolarViewport, ReadOnlyViewport, Viewport
+
+
+class Axes(session.Style):
+    def __init__(self, plot, *svargs):
+        self.plot = plot
+        super().__init__(svargs, uniqueid=plot.frame.uid)
+
+    def __eq__(self, that):
+        return isinstance(that, type(self)) and (self.plot == that.plot)
+
+    def __ne__(self, that):
+        return not (self == that)
+
+    def __iter__(self):
+        self._iter_axes = ('x_axis', 'y_axis', 'z_axis', 'r_axis', 'theta_axis')
+        self._iter_axis_index = 0
+        return self
+
+    def __next__(self):
+        try:
+            attr_name = self._iter_axes[self._iter_axis_index]
+            self._iter_axis_index += 1
+            attr = getattr(self, attr_name, None)
+            if attr is not None:
+                return attr
+            else:
+                return next(self)
+        except IndexError:
+            raise StopIteration
+
+    def next(self):  # if sys.version_info < (3,)
+        return self.__next__()
+
+    @property
+    def grid_area(self):
+        """`GridArea`: Area bounded by the axes.
+
+        This controls the background color and border of the axes::
+
+            >>> from tecplot.constant import Color
+            >>> plot.axes.grid_area.fill_color = Color.LightGreen
+        """
+        return GridArea(self)
+
+    @property
+    def preserve_scale(self):
+        """`bool`: Preserve scale (spacing between ticks) on range change.
+
+        This maintains the axis scaling, i.e. the distance between values along
+        the axis. If `False`, the axes length will be preserved when the range
+        changes::
+
+            >>> plot.axes.preserve_scale = False
+            >>> # get axis via "plot.axes.x_axis(0)" for line plots
+            >>> # or "plot.axes.x_axis" for field or sketch plots
+            >>> axis.max = 10 # axis scale is changed (length is preserved)
+        """
+        return self._get_style(bool, sv.PRESERVEAXISSCALE)
+
+    @preserve_scale.setter
+    def preserve_scale(self, value):
+        self._set_style(bool(value), sv.PRESERVEAXISSCALE)
+
+
+class Axes2D(Axes):
+    @property
+    def precise_grid(self):
+        """`PreciseGrid`: Precise dot grid.
+
+        This is a set of small dots drawn at the intersection of every minor
+        gridline. In line plots, the axis assignments for the first active
+        mapping govern the precise dot grid. The precise dot grid option is
+        disabled for the 3D Cartesian plots and Line plots when either axis for
+        the first active line mapping uses a log scale::
+
+            >>> plot.axes.precise_grid.show = True
+        """
+        return PreciseGrid(self)
+
+
+class CartesianAxes(Axes):
+    @property
+    def xy_ratio(self):
+        """`float`: X:Y axis scaling ratio in percent.
+
+        This requires the axes to be in dependent mode::
+
+            >>> from tecplot.constant import AxisMode
+            >>> plot.axes.axis_mode = AxisMode.XYDependent
+            >>> plot.axes.xy_ratio = 2
+        """
+        return self._get_style(float, sv.DEPXTOYRATIO)
+
+    @xy_ratio.setter
+    def xy_ratio(self, value):
+        self._set_style(float(value), sv.DEPXTOYRATIO)
+
+
+class Cartesian2DAxes(CartesianAxes):
+    @property
+    def auto_adjust_ranges(self):
+        """`bool`: Automatically adjust axis ranges to nice values.
+
+        Axes limits will be adjusted to have the smallest number of significant
+        digits possible::
+
+            >>> plot.axes.auto_adjust_ranges = False
+        """
+        return self._get_style(bool, sv.AUTOADJUSTRANGESTONICEVALUES)
+
+    @auto_adjust_ranges.setter
+    def auto_adjust_ranges(self, value):
+        self._set_style(bool(value), sv.AUTOADJUSTRANGESTONICEVALUES)
+
+    @property
+    def axis_mode(self):
+        """`AxisMode`: Controls automatic adjustment of axis ranges.
+
+        Possible values: `Independent`, `XYDependent`.
+
+        If set to `XYDependent`, then setting the range of one axis
+        automatically scales the other indicated axes proportionally to
+        maintain the aspect ratio of the plot, effectively zooming in or out.
+        If set to `Independent`, adjusting the range of one axis has no effect
+        on other axes. Defaults to `Independent` for XY line plots,
+        `XYDependent` for 2D Cartesian plots. Example usage::
+
+            >>> from tecplot.constant import AxisMode
+            >>> plot.axes.axis_mode = AxisMode.Independent
+        """
+        return self._get_style(AxisMode, sv.AXISMODE)
+
+    @axis_mode.setter
+    def axis_mode(self, value):
+        self._set_style(AxisMode(value), sv.AXISMODE)
+
+    @property
+    def viewport(self):
+        """`Cartesian2DViewport`: Area of the frame used by the plot axes.
+
+        Example usage::
+
+            >>> plot.axes.viewport.left = 5
+            >>> plot.axes.viewport.right = 95
+            >>> plot.axes.viewport.top = 95
+            >>> plot.axes.viewport.bottom = 5
+        """
+        return Cartesian2DViewport(self)
+
+    @property
+    def grid_area(self):
+        """`GridArea`: Area bounded by the axes.
+
+        This controls the background color and border of the axes::
+
+            >>> from tecplot.constant import Color
+            >>> plot.axes.grid_area.fill_color = Color.LightGreen
+        """
+        return Cartesian2DGridArea(self)
+
+
+class Cartesian3DAxes(CartesianAxes):
+    @property
+    def xz_ratio(self):
+        """`float`: X:Z axis scaling ratio in percent.
+
+        This requires the axes to be in dependent mode::
+
+            >>> from tecplot.constant import AxisMode
+            >>> plot.axes.axis_mode = AxisMode.XYZDependent
+            >>> plot.axes.xy_ratio = 2
+            >>> plot.axes.xz_ratio = 20
+        """
+        return self._get_style(float, sv.DEPXTOZRATIO)
+
+    @xz_ratio.setter
+    def xz_ratio(self, value):
+        self._set_style(float(value), sv.DEPXTOZRATIO)
+
+    @inherited_property(Cartesian2DAxes)
+    def axis_mode(self):
+        """`AxisMode`: Scale dependencies along each axis.
+
+        Possible values: `Independent`, `XYDependent`, `XYZDependent`.
+
+        If set to `XYDependent` or `XYZDependent`, then setting the range of
+        one axis automatically scales the other indicated axes proportionally
+        to maintain the aspect ratio of the plot, effectively zooming in or
+        out. If set to `Independent`, adjusting the range of one axis has no
+        effect on other axes. Defaults to `XYZDependent` for 3D Cartesian
+        plots. Both dependent modes allow specifying the axes scaling ratios::
+
+            >>> from tecplot.constant import AxisMode
+            >>> plot.axes.axis_mode = AxisMode.XYZDependent
+            >>> plot.axes.xy_ratio = 2
+            >>> plot.axes.xz_ratio = 20
+        """
+
+    @property
+    def aspect_ratio_limit(self):
+        """`float`: Scale limit of the axes aspect ratio.
+
+        This is the limit above which the axes relative scales will be pegged
+        to `aspect_ratio_reset`. The following example will set the aspect
+        ratio between scales to 1 if they first exceed a ratio of 10::
+
+            >>> plot.axes.aspect_ratio_limit = 10
+            >>> plot.axes.aspect_ratio_reset = 1
+            >>> plot.axes.reset_scale()
+        """
+        return self._get_style(float, sv.ASPECTRATIOLIMIT)
+
+    @aspect_ratio_limit.setter
+    def aspect_ratio_limit(self, value):
+        self._set_style(float(value), sv.ASPECTRATIOLIMIT)
+
+    @property
+    def aspect_ratio_reset(self):
+        """`float`: Axes scale aspect ratio used when `aspect_ratio_limit` is exceeded.
+
+        This is the aspect ratio used to scale the axes when the data's aspect
+        ratio exceeds the value set to `aspect_ratio_limit`. The following
+        example will set the aspect ratio between scales to 10 if they first
+        exceed a ratio of 15::
+
+            >>> plot.axes.aspect_ratio_limit = 15
+            >>> plot.axes.aspect_ratio_reset = 10
+            >>> plot.axes.reset_scale()
+        """
+        return self._get_style(float, sv.ASPECTRATIORESET)
+
+    @aspect_ratio_reset.setter
+    def aspect_ratio_reset(self, value):
+        self._set_style(float(value), sv.ASPECTRATIORESET)
+
+    @property
+    def range_aspect_ratio_limit(self):
+        """`float`: Range limit of the axes aspect ratio.
+
+        This is the limit above which the axes' relative ranges will be pegged
+        to `range_aspect_ratio_reset`. The following example will set the
+        aspect ratio between ranges to 1 if they first exceed a ratio of 10::
+
+            >>> plot.axes.range_aspect_ratio_limit = 10
+            >>> plot.axes.range_aspect_ratio_reset = 1
+            >>> plot.axes.reset_range()
+        """
+        return self._get_style(float, sv.BOXASPECTRATIOLIMIT)
+
+    @range_aspect_ratio_limit.setter
+    def range_aspect_ratio_limit(self, value):
+        self._set_style(float(value), sv.BOXASPECTRATIOLIMIT)
+
+    @property
+    def range_aspect_ratio_reset(self):
+        """`float`: Axes range aspect ratio used `range_aspect_ratio_limit` is exceeded.
+
+        This is the aspect ratio used to set the ranges of the axes when the
+        axes' aspect ratios exceed the value of `range_aspect_ratio_limit`. The
+        following example will set the aspect ratio between ranges to 10 if
+        they first exceed a ratio of 15::
+
+            >>> plot.axes.range_aspect_ratio_limit = 15
+            >>> plot.axes.range_aspect_ratio_reset = 10
+            >>> plot.axes.reset_range()
+        """
+        return self._get_style(float, sv.BOXASPECTRATIORESET)
+
+    @range_aspect_ratio_reset.setter
+    def range_aspect_ratio_reset(self, value):
+        self._set_style(float(value), sv.BOXASPECTRATIORESET)
+
+    @property
+    def auto_edge_assignment(self):
+        """`bool`: Enable automatically choosing which edges to label.
+
+        Example usage::
+
+            >>> plot.axes.auto_edge_assignment = True
+        """
+        return self._get_style(bool, sv.EDGEAUTORESET)
+
+    @auto_edge_assignment.setter
+    def auto_edge_assignment(self, value):
+        self._set_style(bool(value), sv.EDGEAUTORESET)
+
+    @property
+    def viewport(self):
+        """`ReadOnlyViewport`: Area of the frame used by the plot axes.
+
+        Example usage::
+
+            >>> print(plot.axes.viewport.bottom)
+            5
+        """
+        return ReadOnlyViewport(self)
+
+    @lock()
+    def reset_scale(self):
+        """Recalculate and set the scale factors for each axis.
+
+        Aspect ratio limits are taken into account::
+
+            >>> plot.axes.reset_scale()
+        """
+        with self.plot.frame.activated():
+            if not _tecutil.Reset3DScaleFactors():
+                raise TecplotSystemError()
+
+    @lock()
+    def reset_range(self):
+        """Recalculate and set the ranges for each axis.
+
+        Example usage::
+
+            >>> plot.axes.reset_range()
+        """
+        with self.plot.frame.activated():
+            if not _tecutil.Reset3DAxes():
+                raise TecplotSystemError()
+
+    @lock()
+    def reset_origin(self, location=OriginResetLocation.DataCenter):
+        """Set the origin to the specified location.
+
+        Parameters:
+            location (`OriginResetLocation`, optional): Either the center of
+                the data with `OriginResetLocation.DataCenter` (default) or the
+                center of the viewport with `OriginResetLocation.ViewCenter`.
+
+        Example usage::
+
+            >>> from tecplot.constant import OriginResetLocation
+            >>> plot.axes.reset_origin(OriginResetLocation.ViewCenter)
+        """
+        with self.plot.frame.activated():
+            with tecutil.ArgList() as arglist:
+                arglist[sv.ORIGINRESETLOCATION] = OriginResetLocation(location)
+                if not _tecutil.Reset3DOriginX(arglist):
+                    raise TecplotSystemError()
+
+    @property
+    def grid_area(self):
+        """`Cartesian3DGridArea`: Area of the viewport used by the axes.
+
+        Example usage::
+
+            >>> plot.axes.grid_area.fill_color = Color.LightGreen
+        """
+        return Cartesian3DGridArea(self)
+
+    @property
+    def padding(self):
+        """`float`: Margin of axis padding around data in percent of data extent.
+
+        Example usage::
+
+            >>> plot.axes.padding = 5
+        """
+        style = session.Style(**self._kw)
+        return style._get_style(float, sv.GLOBALTHREED, sv.AXISBOXPADDING)
+
+    @padding.setter
+    def padding(self, value):
+        style = session.Style(**self._kw)
+        style._set_style(float(value), sv.GLOBALTHREED, sv.AXISBOXPADDING)
+
+    @property
+    def orientation_axis(self):
+        """`OrientationAxis`: Get the 3D Orientation Axes.
+
+        Example usage::
+
+            >>> # Hide the orientation axes
+            >>> plot.axes.orientation_axis.show = False
+        """
+        return OrientationAxis(self)
+
+
+class SketchAxes(Cartesian2DAxes, Axes2D):
+    """(X, Y) axes style control for sketch plots.
+
+    Sketch plots have cartesian *x* and *y* axes which can be adjusted using
+    the viewport:
+
+    .. code-block:: python
+        :emphasize-lines: 7-13
+
+        import tecplot as tp
+        from tecplot.constant import PlotType
+
+        frame = tp.active_frame()
+        plot = frame.plot(PlotType.Sketch)
+
+        plot.axes.x_axis.show = True
+        plot.axes.y_axis.show = True
+
+        plot.axes.viewport.left = 10
+        plot.axes.viewport.right = 90
+        plot.axes.viewport.bottom = 10
+        plot.axes.viewport.top = 90
+
+        tp.export.save_png('axes_sketch.png', 600, supersample=3)
+
+    ..  figure:: /_static/images/axes_sketch.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    def __init__(self, plot):
+        super().__init__(plot, sv.SKETCHAXIS)
+
+    @property
+    def x_axis(self):
+        """`SketchAxis`: X-axis style control.
+
+        Example usage::
+
+            >>> plot.axes.x_axis.show = True
+        """
+        return SketchAxis(self, sv.X)
+
+    @property
+    def y_axis(self):
+        """`SketchAxis`: Y-axis style control.
+
+        Example usage::
+
+            >>> plot.axes.y_axis.show = True
+        """
+        return SketchAxis(self, sv.Y)
+
+
+class Cartesian2DFieldAxes(Cartesian2DAxes, Axes2D):
+    """(X, Y) axes style control for 2D field plots.
+
+    .. code-block:: python
+        :emphasize-lines: 15-17
+
+        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.show_shade = False
+        plot.show_contour = True
+
+        plot.axes.auto_adjust_ranges = True
+        plot.axes.precise_grid.show = True
+        plot.axes.precise_grid.size = 0.05
+
+        plot.view.fit()
+
+        # ensure consistent output between interactive (connected) and batch
+        plot.contour(0).levels.reset_to_nice()
+
+        tp.export.save_png('axes_2d.png', 600, supersample=3)
+
+    ..  figure:: /_static/images/axes_2d.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    def __init__(self, plot):
+        super().__init__(plot, sv.TWODAXIS)
+
+    @property
+    def x_axis(self):
+        """`Cartesian2DFieldAxis`: X-axis style control.
+
+        Example usage::
+
+            >>> plot.axes.x_axis.show = False
+        """
+        return Cartesian2DFieldAxis(self, sv.X)
+
+    @property
+    def y_axis(self):
+        """`Cartesian2DFieldAxis`: Y-axis style control.
+
+        Example usage::
+
+            >>> plot.axes.y_axis.show = False
+        """
+        return Cartesian2DFieldAxis(self, sv.Y)
+
+
+class Cartesian3DFieldAxes(Cartesian3DAxes):
+    """(X, Y, Z) axes style control for 3D field plots.
+
+    .. code-block:: python
+        :emphasize-lines: 12-16
+
+        from os import path
+        import tecplot as tp
+        from tecplot.constant import PlotType, Color
+
+        examples_dir = tp.session.tecplot_examples_directory()
+        infile = path.join(examples_dir, 'SimpleData', 'Sphere.lpk')
+        dataset = tp.load_layout(infile)
+
+        frame = tp.active_frame()
+        plot = frame.plot()
+
+        plot.axes.x_axis.show = True
+        plot.axes.y_axis.show = True
+        plot.axes.z_axis.show = True
+        plot.axes.grid_area.fill_color = Color.SkyBlue
+        plot.axes.padding = 20
+
+        plot.view.fit()
+
+        tp.export.save_png('axes_3d.png', 600, supersample=3)
+
+    ..  figure:: /_static/images/axes_3d.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    def __init__(self, plot):
+        super().__init__(plot, sv.THREEDAXIS)
+
+    @property
+    def x_axis(self):
+        """`Cartesian3DFieldAxis`: X-axis style control.
+
+        Example usage::
+
+            >>> plot.axes.x_axis.show = True
+        """
+        return Cartesian3DFieldAxis(self, sv.X)
+
+    @property
+    def y_axis(self):
+        """`Cartesian3DFieldAxis`: Y-axis style control.
+
+        Example usage::
+
+            >>> plot.axes.y_axis.show = True
+        """
+        return Cartesian3DFieldAxis(self, sv.Y)
+
+    @property
+    def z_axis(self):
+        """`Cartesian3DFieldAxis`: Z-axis style control.
+
+        Example usage::
+
+            >>> plot.axes.z_axis.show = True
+        """
+        return Cartesian3DFieldAxis(self, sv.Z)
+
+
+class PolarLineAxes(Axes2D):
+    """(R, Theta) axes style control for polar plots.
+
+    Example usage:
+
+    .. code-block:: python
+        :emphasize-lines: 19-20
+
+        import numpy as np
+        import tecplot as tp
+        from tecplot.constant import PlotType, ThetaMode
+
+        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 = np.max(r)
+        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
+
+        plot.view.fit()
+
+        tp.export.save_png('axes_polar.png', 600, supersample=3)
+
+    ..  figure:: /_static/images/axes_polar.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    def __init__(self, plot):
+        super().__init__(plot, sv.POLARAXIS)
+
+    @property
+    def r_axis(self):
+        """`RadialLineAxis`: Radial axis style control.
+
+        Example usage::
+
+            >>> plot.axes.r_axis.title.text = 'R (meters)'
+        """
+        return RadialLineAxis(self)
+
+    @property
+    def theta_axis(self):
+        """`PolarAngleLineAxis`: Polar-angle axis style control.
+
+        Example usage::
+
+            >>> plot.axes.theta_axis.title.text = 'Theta (radians)'
+        """
+        return PolarAngleLineAxis(self)
+
+    @property
+    def viewport(self):
+        """`PolarViewport`: Area of the frame used by the plot axes outside the grid area.
+
+        Example usage::
+
+            >>> from tecplot.constant import Color
+            >>> plot.axes.viewport.fill_color = Color.LightGreen
+        """
+        return PolarViewport(self)
+
+
+class XYLineAxes(Cartesian2DAxes, Axes2D):
+    """(X, Y) axes style control for line plots.
+
+    The ``axes`` property of a `XYLinePlot` allows access to the several ``x``
+    and ``y`` axes by index. Linemaps can use any of the five such axes. In
+    this example, we create two sets of data with different scales and the
+    second y-axis is used on the right side of the plot:
+
+    .. code-block:: python
+        :emphasize-lines: 32,44
+
+        import numpy as np
+        import tecplot as tp
+        from tecplot.constant import PlotType, Color
+
+        frame = tp.active_frame()
+
+        npoints = 100
+        x = np.linspace(-10,10,npoints)
+        t = x**2
+        p = 0.1 * np.sin(x)
+
+        dataset = frame.create_dataset('data', ['Position (m)', 'Temperature (K)',
+                                                'Pressure (Pa)'])
+        zone = dataset.add_ordered_zone('zone', (100,))
+        zone.values('Position (m)')[:] = x
+        zone.values('Temperature (K)')[:] = t
+        zone.values('Pressure (Pa)')[:] = p
+
+        plot = frame.plot(PlotType.XYLine)
+        plot.activate()
+        plot.delete_linemaps()
+
+        temp = plot.add_linemap('temp', zone, dataset.variable('Position (m)'),
+                         dataset.variable('Temperature (K)'))
+        press = plot.add_linemap('press', zone, dataset.variable('Position (m)'),
+                                 dataset.variable('Pressure (Pa)'))
+
+        # Color the line and the y-axis for temperature
+        temp.line.color = Color.RedOrange
+        temp.line.line_thickness = 0.8
+
+        ax = plot.axes.y_axis(0)
+        ax.line.color = temp.line.color
+        ax.tick_labels.color = temp.line.color
+        ax.title.color = temp.line.color
+
+        # set pressure linemap to second x-axis
+        press.y_axis_index = 1
+
+        # Color the line and the y-axis for pressure
+        press.line.color = Color.Chartreuse
+        press.line.line_thickness = 0.8
+
+        ax = plot.axes.y_axis(1)
+        ax.line.color = press.line.color
+        ax.tick_labels.color = press.line.color
+        ax.title.color = press.line.color
+
+        tp.export.save_png('axes_line.png', 600, supersample=3)
+
+    ..  figure:: /_static/images/axes_line.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    def __init__(self, plot):
+        super().__init__(plot, sv.XYLINEAXIS)
+
+    def __iter__(self):
+        self._iter_axes = ['x_axis', 'y_axis'] * 5
+        self._iter_axis_index = 0
+        return self
+
+    def __next__(self):
+        try:
+            attr_name = self._iter_axes[self._iter_axis_index]
+            index = self._iter_axis_index // 2
+            self._iter_axis_index += 1
+            return getattr(self, attr_name)(index)
+        except IndexError:
+            raise StopIteration
+
+    def x_axis(self, index):
+        """`XYLineAxis`: X-axis style control.
+
+        There are five x-axes for each `XYLinePlot`, indexed from 0 to 4
+        inclusive::
+
+            >>> plot.axes.x_axis(0).show = True
+        """
+        return XYLineAxis(self, sv.X, index)
+
+    def y_axis(self, index):
+        """`XYLineAxis`: Y-axis style control.
+
+        There are five y-axes for each `XYLinePlot`, indexed from 0 to 4
+        inclusive::
+
+            >>> plot.axes.y_axis(0).show = True
+        """
+        return XYLineAxis(self, sv.Y, index)
+
+
+class OrientationAxis(session.Style):
+    """The orientation axis for 3D Field plots.
+
+    This is the small (x, y, z) reference axis object which can moved, resized
+    and modified using this class.
+
+    By default, all 3D plots show the 3D orientation axis in the upper right
+    of the frame. It can be repositioned by setting `position` as shown
+    below:
+
+    .. code-block:: python
+        :emphasize-lines: 12-13
+
+        from os import path
+        import tecplot as tp
+        from tecplot.constant import Color
+
+        examples_dir = tp.session.tecplot_examples_directory()
+        infile = path.join(examples_dir, 'SimpleData', 'Sphere.lpk')
+        dataset = tp.load_layout(infile)
+
+        frame = tp.active_frame()
+        plot = frame.plot()
+
+        plot.axes.orientation_axis.position = 15, 15
+        plot.axes.orientation_axis.color = Color.BrightCyan
+
+        plot.axes.reset_range()
+        plot.view.fit()
+
+        tp.export.save_png('axes_orientation.png', 600, supersample=3)
+
+    ..  figure:: /_static/images/axes_orientation.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    def __init__(self, axes):
+        self.axes = axes
+        super().__init__(axes._sv, sv.FRAMEAXIS, **axes._kw)
+
+    @property
+    def show(self):
+        """`bool`: Enable drawing of the orientation axis.
+
+        Example usage::
+
+            >>> plot.axes.orientation_axis.show = False
+        """
+        return self._get_style(bool, sv.SHOW)
+
+    @show.setter
+    def show(self, value):
+        self._set_style(bool(value), sv.SHOW)
+
+    @property
+    def size(self):
+        """`float`: Size of the orientation axis as a percentage of frame size (0-100).
+
+        Example usage::
+
+            >>> plot.axes.orientation_axis.size = 4.0
+        """
+        return self._get_style(float, sv.SIZE)
+
+    @size.setter
+    def size(self, value):
+        self._set_style(float(value), sv.SIZE)
+
+    @property
+    def line_thickness(self):
+        """`float`: Line thickness used when drawing the orientation axis as a percentage of frame height.
+
+        Example usage::
+
+            >>> plot.axes.orientation_axis.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)
+
+    @property
+    def color(self):
+        """`Color`: `Color` of the orientation axes.
+
+        Example usage::
+
+            >>> from tecplot.constant import Color
+            >>> plot.axes.orientation_axis.color = Color.Cyan
+        """
+        return self._get_style(Color, sv.COLOR)
+
+    @color.setter
+    def color(self, value):
+        self._set_style(Color(value), sv.COLOR)
+
+    _Position = namedtuple('Position', ['x', 'y'])
+
+    @property
+    def position(self):
+        """`tuple`: ``(x, y)`` position of the orientation axis.
+
+        The position is in percent from the lower-left corner of the viewport::
+
+            >>> plot.axes.orientation_axis.position = (15, 15)
+        """
+        x = self._get_style(float, sv.XYPOS, sv.X)
+        y = self._get_style(float, sv.XYPOS, sv.Y)
+        return OrientationAxis._Position(x, y)
+
+    @position.setter
+    def position(self, *pos):
+        pos = OrientationAxis._Position(*flatten_args(*pos))
+        self._set_style(float(pos.x), sv.XYPOS, sv.X)
+        self._set_style(float(pos.y), sv.XYPOS, sv.Y)
+
+    @property
+    def show_variable_name(self):
+        """`bool`: Use variable names instead of 'X', 'Y' and 'Z'.
+
+        Example usage::
+
+            >>> plot.axes.orientation_axis.show_variable_name = True
+        """
+        return self._get_style(bool, sv.SHOWVARIABLENAME)
+
+    @show_variable_name.setter
+    def show_variable_name(self, value):
+        self._set_style(bool(value), sv.SHOWVARIABLENAME)