# Source code for tecplot.plot.axes

    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)