# Source code for tecplot.plot.contour

    from builtins import int, str, super

    from ..tecutil import _tecutil
    from ..constant import *
    from ..exception import *
    from .. import legend, session, tecutil, text
    from ..tecutil import Index, flatten_args, lock, lock_attributes, sv

    class ContourColormapOverride(session.Style):
        """Assigns contour bands to specific color.

        Specific contour bands can be assigned a unique basic color. This is useful
        for forcing a particular region to use blue, for example, to designate an
        area of water. You can define up to 16 color overrides:

        .. code-block:: python
            :emphasize-lines: 29,32-36

            from os import path
            import tecplot as tp
            from tecplot.constant import *

            # load the data
            examples_dir = tp.session.tecplot_examples_directory()
            datafile = path.join(examples_dir, 'SimpleData', 'HeatExchanger.plt')
            dataset = tp.data.load_tecplot(datafile)

            # set plot type to 2D field plot
            frame = tp.active_frame()
            frame.plot_type = PlotType.Cartesian2D
            plot = frame.plot()

            # show boundary faces and contours
            surfaces = plot.fieldmap(0).surfaces
            surfaces.surfaces_to_plot = SurfacesToPlot.BoundaryFaces
            plot.show_contour = True

            # by default, contour 0 is the one that's shown,
            # set the contour's variable, colormap and number of levels
            contour = plot.contour(0)
            contour.variable = dataset.variable('T(K)')
            contour.colormap_name = 'Sequential - Yellow/Green/Blue'
            contour.levels.reset(9)

            # turn on colormap overrides for this contour
            contour_filter = contour.colormap_filter
            contour_filter.show_overrides = True

            # turn on override 0, coloring the first 4 levels red
            contour_override = contour_filter.override(0)
            contour_override.show = True
            contour_override.color = Color.Red
            contour_override.start_level = 7
            contour_override.end_level = 8

            # save image to file
            tp.export.save_png('contour_override.png', 600, supersample=3)

        .. figure:: /_static/images/contour_override.png
            :width: 300px
            :figwidth: 300px
        """
        def __init__(self, index, colormap_filter):
            self.index = Index(index)
            self.colormap_filter = colormap_filter
            super().__init__(colormap_filter._sv, sv.COLORMAPOVERRIDE,
                             **colormap_filter._kw)

        @property
        def show(self):
            """`bool`: Include this colormap override when filter is shown.

            Example usage::

                >>> colormap_filter = plot.contour(0).colormap_filter
                >>> cmap_override = colormap_filter.override(0)
                >>> cmap_override.show = True
            """
            return self._get_style(bool, sv.INCLUDE)

        @show.setter
        def show(self, show):
            self._set_style(bool(show), sv.INCLUDE)

        @property
        def color(self):
            """`Color`: Color which will override the colormap.

            Example usage::

                >>> from tecplot.constant import Color
                >>> colormap_filter = plot.contour(0).colormap_filter
                >>> cmap_override = colormap_filter.override(0)
                >>> cmap_override.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 start_level(self):
            """`int`: First level to override.

            Example usage::

                >>> colormap_filter = plot.contour(0).colormap_filter
                >>> cmap_override = colormap_filter.override(0)
                >>> cmap_override.start_level = 2
            """
            return self._get_style(int, sv.STARTLEVEL)

        @start_level.setter
        def start_level(self,value):
            self._set_style(int(value), sv.STARTLEVEL)

        @property
        def end_level(self):
            """`int`: Last level to override.

            Example usage::

                >>> colormap_filter = plot.contour(0).colormap_filter
                >>> cmap_override = colormap_filter.override(0)
                >>> cmap_override.end_level = 2
            """
            return self._get_style(int, sv.ENDLEVEL)

        @end_level.setter
        def end_level(self,value):
            self._set_style(int(value), sv.ENDLEVEL)

    class ContourColormapZebraShade(session.Style):
        """This filter sets a uniform color for every other band.

        Setting the color to `None` turns the bands off and makes them
        transparent:

        .. code-block:: python
            :emphasize-lines: 20-22

            from os import path
            import numpy as np
            import tecplot as tp
            from tecplot.constant import Color, SurfacesToPlot

            # load the data
            examples_dir = tp.session.tecplot_examples_directory()
            datafile = path.join(examples_dir,'SimpleData','Pyramid.plt')
            dataset = tp.data.load_tecplot(datafile)

            # show boundary faces and contours
            plot = tp.active_frame().plot()
            surfaces = plot.fieldmap(0).surfaces
            surfaces.surfaces_to_plot = SurfacesToPlot.BoundaryFaces
            plot.show_contour = True
            plot.show_shade = False

            # set zebra filter on and make the zebra contours transparent
            cont0 = plot.contour(0)
            zebra = cont0.colormap_filter.zebra_shade
            zebra.show = True
            zebra.transparent = True

            # ensure consistent output between interactive (connected) and batch
            cont0.levels.reset_to_nice()

            tp.export.save_png('contour_zebra.png', 600, supersample=3)

        .. figure:: /_static/images/contour_zebra.png
            :width: 300px
            :figwidth: 300px
        """
        def __init__(self, colormap_filter):
            self.colormap_filter = colormap_filter
            super().__init__(colormap_filter._sv, sv.ZEBRA,
                             uniqueid=self.colormap_filter.contour.plot.frame.uid,
                             offset1=self.colormap_filter.contour.index)

        @property
        def show(self):
            """`bool`: Show zebra shading in this `ContourGroup`.

            Example usage::

                >>> cmap_filter = plot.contour(0).colormap_filter
                >>> cmap_filter.zebra_shade.show = True
            """
            return self._get_style(bool, sv.INCLUDE)

        @show.setter
        def show(self,value):
            self._set_style(bool(value), sv.INCLUDE)

        @property
        def color(self):
            """`Color`: Color of the zebra shading.

            Example usage::

                >>> from tecplot.constant import Color
                >>> filter = plot.contour(0).colormap_filter
                >>> zebra = filter.zebra_shade
                >>> zebra.show = True
                >>> zebra.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 transparent(self):
            """`bool`: Set the the zebra bands to be transparent.

            Example usage::

                >>> filter = plot.contour(0).colormap_filter
                >>> zebra = filter.zebra_shade
                >>> zebra.show = True
                >>> zebra.transparent = True
            """
            return self._get_style(bool, sv.ISTRANSPARENT)

        @transparent.setter
        def transparent(self, value):
            self._set_style(bool(value), sv.ISTRANSPARENT)

    class ContourGroupStyle(session.Style):
        def __init__(self, contour, *svargs):
            kw = dict(uniqueid=contour.plot.frame.uid, offset1=contour.index)
            super().__init__(contour._sv, *svargs, **kw)

    class ContourColorCutoff(ContourGroupStyle):
        """Color-mapped value limits to display.

        This lets you specify a range within which contour flooding and
        multi-colored objects, such as scatter symbols, are displayed:

        .. code-block:: python
            :emphasize-lines: 17-22

            import os
            import tecplot as tp
            from tecplot.constant import PlotType, SurfacesToPlot

            # load the data
            examples_dir = tp.session.tecplot_examples_directory()
            datafile = os.path.join(examples_dir,'SimpleData','Pyramid.plt')
            dataset = tp.data.load_tecplot(datafile)

            # show boundary faces and contours
            plot = tp.active_frame().plot()
            surfaces = plot.fieldmap(0).surfaces
            surfaces.surfaces_to_plot = SurfacesToPlot.BoundaryFaces
            plot.show_contour = True

            # cutoff contour flooding outside min/max range
            cutoff = plot.contour(0).color_cutoff
            cutoff.include_min = True
            cutoff.min = 0.5
            cutoff.include_max = True
            cutoff.max = 1.0
            cutoff.inverted = True

            # ensure consistent output between interactive (connected) and batch
            plot.contour(0).levels.reset_to_nice()

            tp.export.save_png('contour_color_cutoff.png',600)

        .. figure:: /_static/images/contour_color_cutoff.png
            :width: 300px
            :figwidth: 300px
        """
        def __init__(self, contour):
            self.contour = contour
            super().__init__(contour, sv.COLORCUTOFF)

        @property
        def include_min(self):
            """`bool`: Use the minimum cutoff value.

            Example usage::

                >>> plot.contour(0).color_cutoff.include_min = True
                >>> plot.contour(0).color_cutoff.min = 3.14
            """
            return self._get_style(bool, sv.INCLUDEMIN)

        @include_min.setter
        def include_min(self, value):
            self._set_style(bool(value), sv.INCLUDEMIN)

        @property
        def include_max(self):
            """`bool`: Use the maximum cutoff value.

            Thie example turns off the maximum cutoff::

                >>> plot.contour(0).color_cutoff.include_max = False
            """
            return self._get_style(bool, sv.INCLUDEMAX)

        @include_max.setter
        def include_max(self, value):
            self._set_style(bool(value), sv.INCLUDEMAX)

        @property
        def min(self):
            """`float` or `None`: The minimum cutoff value.

            The ``include_min`` must be set to `True`::

                >>> plot.contour(0).color_cutoff.include_min = True
                >>> plot.contour(0).color_cutoff.min = 3.14
            """
            return self._get_style(float, sv.RANGEMIN)

        @min.setter
        def min(self,value):
            self._set_style(float(value), sv.RANGEMIN)

        @property
        def max(self):
            """`float` or `None`: The maximum cutoff value.

            The ``include_max`` must be set to `True`::

                >>> plot.contour(0).color_cutoff.include_max = True
                >>> plot.contour(0).color_cutoff.max = None
            """
            return self._get_style(float, sv.RANGEMAX)

        @max.setter
        def max(self,value):
            self._set_style(float(value), sv.RANGEMAX)

        @property
        def inverted(self):
            """`bool`: Cuts values outside the range instead of inside.

            .. code-block:: python

                >>> plot.contour(0).color_cutoff.inverted = True
            """
            return self._get_style(bool, sv.INVERTCUTOFF)

        @inverted.setter
        def inverted(self,value):
            self._set_style(bool(value), sv.INVERTCUTOFF)

    class ContourColormapFilter(ContourGroupStyle):
        """Controls how the colormap is rendered for a given contour.

        .. code-block:: python
            :emphasize-lines: 27-31

            from os import path
            import tecplot as tp
            from tecplot.constant import *

            # load the data
            examples_dir = tp.session.tecplot_examples_directory()
            datafile = path.join(examples_dir,'SimpleData','HeatExchanger.plt')
            ds = tp.data.load_tecplot(datafile)

            # set plot type to 2D field plot
            frame = tp.active_frame()
            frame.plot_type = PlotType.Cartesian2D
            plot = frame.plot()

            # show boundary faces and contours
            surfaces = plot.fieldmap(0).surfaces
            surfaces.surfaces_to_plot = SurfacesToPlot.BoundaryFaces
            plot.show_contour = True

            # by default, contour 0 is the one that's shown,
            # set the contour's variable, colormap and number of levels
            contour = plot.contour(0)
            contour.variable = ds.variable('P(N)')

            # cycle through the colormap three times and reversed
            # show a faithful (non-approximate) continuous distribution
            contour_filter = contour.colormap_filter
            contour_filter.num_cycles = 3
            contour_filter.reversed = True
            contour_filter.fast_continuous_flood = False
            contour_filter.distribution = ColorMapDistribution.Continuous

            # ensure consistent output between interactive (connected) and batch
            contour.levels.reset_to_nice()

            # save image to file
            tp.export.save_png('contour_filtered.png', 600, supersample=3)

        .. figure:: /_static/images/contour_filtered.png
            :width: 300px
            :figwidth: 300px
        """
        def __init__(self, contour):
            self.contour = contour
            super().__init__(self.contour, sv.COLORMAPFILTER)

        def override(self, index):
            """Returns a `ContourColormapOverride` object by index.

            Parameters:
                index (`int`): The index of the colormap override object.

            Returns:
                `ContourColormapOverride`: The class controlling the specific
                contour colormap override requested by index.

            Example::

                >>> cmap_override = plot.contour(0).colormap_filter.override(0)
                >>> cmap_override.show = True
            """
            return ContourColormapOverride(index, self)

        @property
        def zebra_shade(self):
            """`ContourColormapZebraShade`: Returns a `ContourColormapZebraShade` filtering object.

            Example usage::

                >>> zebra = plot.contour(0).colormap_filter.zebra_shade
                >>> zebra.show = True
            """
            return ContourColormapZebraShade(self)

        @property
        def show_overrides(self):
            """`bool`: Enable the colormap overrides in this contour group.

            The overrides themselves must be turned on as well for this
            to have an effect on the resulting plot::

                >>> contour = plot.contour(0)
                >>> cmap_filter = contour.colormap_filter
                >>> cmap_filter.show_overrides = True
                >>> cmap_filter.override(0).show = True
            """
            return self._get_style(bool, sv.COLORMAPOVERRIDEACTIVE)

        @show_overrides.setter
        def show_overrides(self, show):
            self._set_style(bool(show), sv.COLORMAPOVERRIDEACTIVE)

        @property
        def num_cycles(self):
            """`int`: Number of cycles to repeat the colormap.

            >>> plot.contour(0).colormap_filter.num_cycles = 3
            """
            return self._get_style(int, sv.COLORMAPCYCLES)

        @num_cycles.setter
        def num_cycles(self,value):
            self._set_style(int(value), sv.COLORMAPCYCLES)

        @property
        def distribution(self):
            """`ColorMapDistribution`: Rendering style of the colormap.

            Possible values:

            `Banded`
                A solid color is assigned for all values within the band between
                two levels.

            `Continuous`
                The color distribution assigns linearly varying colors to all
                multi-colored objects or contour flooded regions.

            Example::

                >>> from tecplot.constant import ColorMapDistribution
                >>> cmap_filter = plot.contour(0).colormap_filter
                >>> cmap_filter.distribution = ColorMapDistribution.Banded
            """
            return self._get_style(ColorMapDistribution, sv.COLORMAPDISTRIBUTION)

        @distribution.setter
        def distribution(self,value):
            self._set_style(ColorMapDistribution(value), sv.COLORMAPDISTRIBUTION)

        @property
        def reversed(self):
            """`bool`: Reverse the colormap.

            >>> plot.contour(0).colormap_filter.reversed = True
            """
            return self._get_style(bool, sv.REVERSECOLORMAP)

        @reversed.setter
        def reversed(self,value):
            self._set_style(bool(value), sv.REVERSECOLORMAP)

        @property
        def fast_continuous_flood(self):
            """`bool`: Use a fast approximation to continuously flood the colormap.

            Causes each cell to be flooded using interpolation between the color
            values at each node. When the transition from a color at one node to
            another node crosses over the boundary between control points in the
            color spectrum, fast flooding may produce colors not in the spectrum.
            Setting this to `False` is slower, but more accurate::

                >>> cmap_filter = plot.contour(0).colormap_filter
                >>> cmap_filter.fast_continuous_flood = True
            """
            return self._get_style(bool, sv.USEFASTAPPROXCONTINUOUSFLOOD)

        @fast_continuous_flood.setter
        def fast_continuous_flood(self,value):
            self._set_style(bool(value), sv.USEFASTAPPROXCONTINUOUSFLOOD)

        @property
        def continuous_min(self):
            """`float`: Lower limit for continuous colormap flooding.

            Example usage::

                >>> from tecplot.constant import ColorMapDistribution
                >>> cmap_filter = plot.contour(0).colormap_filter
                >>> cmap_filter.distribution = ColorMapDistribution.Continuous
                >>> cmap_filter.continuous_min = 3.1415
            """
            return self._get_style(float, sv.CONTINUOUSCOLOR, sv.CMIN)

        @continuous_min.setter
        def continuous_min(self, value):
            self._set_style(float(value), sv.CONTINUOUSCOLOR, sv.CMIN)

        @property
        def continuous_max(self):
            """`float`: Upper limit for continuous colormap flooding.

            Example set the limits to the (min, max) of a variable in a specific
            zone::

                >>> from tecplot.constant import ColorMapDistribution
                >>> cmap_filter = plot.contour(0).colormap_filter
                >>> cmap_filter.distribution = ColorMapDistribution.Continuous
                >>> pressure = dataset.variable('Pressure').values('My Zone')
                >>> cmap_filter.continuous_min = pressure.min()
                >>> cmap_filter.continuous_max = pressure.max()
            """
            return self._get_style(float, sv.CONTINUOUSCOLOR, sv.CMAX)

        @continuous_max.setter
        def continuous_max(self, value):
            self._set_style(float(value), sv.CONTINUOUSCOLOR, sv.CMAX)

    class ContourLabels(ContourGroupStyle):
        """Contour line label style, position and alignment control.

        These are labels that identify particular contour levels either by value or
        optionally, by number starting from one. The plot type must be lines or
        lines and flood in order to see them:

        .. code-block:: python
            :emphasize-lines: 18-23

            from os import path
            import tecplot as tp
            from tecplot.constant import Color, ContourType, SurfacesToPlot

            # load the data
            examples_dir = tp.session.tecplot_examples_directory()
            datafile = path.join(examples_dir,'SimpleData','Pyramid.plt')
            dataset = tp.data.load_tecplot(datafile)

            # show boundary faces and contours
            plot = tp.active_frame().plot()
            plot.fieldmap(0).contour.contour_type = ContourType.Lines
            surfaces = plot.fieldmap(0).surfaces
            surfaces.surfaces_to_plot = SurfacesToPlot.BoundaryFaces
            plot.show_contour = True

            # set contour label style
            contour_labels = plot.contour(0).labels
            contour_labels.show = True
            contour_labels.auto_align = False
            contour_labels.color = Color.Blue
            contour_labels.background_color = Color.White
            contour_labels.margin = 20

            # ensure consistent output between interactive (connected) and batch
            plot.contour(0).levels.reset_to_nice()

            tp.export.save_png('contour_labels.png', 600, supersample=3)

        .. figure:: /_static/images/contour_labels.png
            :width: 300px
            :figwidth: 300px
        """
        def __init__(self, contour):
            self.contour = contour
            super().__init__(self.contour, sv.LABELS)

        @property
        def show(self):
            """`bool`: Show the contour line labels.

            Contour lines must be on for this to have any effect::

                >>> from tecplot.constant import ContourType
                >>> plot.fieldmap(0).contour.contour_type = ContourType.Lines
                >>> plot.contour(0).labels.show = True
            """
            return self._get_style(bool, sv.SHOW)

        @show.setter
        def show(self,value):
            self._set_style(bool(value), sv.SHOW)

        @property
        def auto_align(self):
            """`bool`: Automatically align the labels with the contour lines.

            This causes the flow of the text to be aligned with the contour lines.
            Otherwise, the labels are aligned with the frame::

                >>> from tecplot.constant import ContourType
                >>> plot.fieldmap(0).contour.contour_type = ContourType.Lines
                >>> plot.contour(0).labels.show = True
                >>> plot.contour(0).labels.auto_align = False
            """
            return self._get_style(bool, sv.ALIGNAUTOLABELS)

        @auto_align.setter
        def auto_align(self,value):
            self._set_style(bool(value), sv.ALIGNAUTOLABELS)

        @property
        def spacing(self):
            """`float`: Spacing between labels along the contour lines.

            This is the distance between each label along each contour line
            in percentage of the frame height::

                >>> from tecplot.constant import ContourType
                >>> plot.fieldmap(0).contour.contour_type = ContourType.Lines
                >>> plot.contour(0).labels.show = True
                >>> plot.contour(0).labels.spacing = 20
            """
            return self._get_style(float, sv.AUTOLABELSPACING)

        @spacing.setter
        def spacing(self,value):
            self._set_style(float(value), sv.AUTOLABELSPACING)

        @property
        def step(self):
            """`int`: Number of contour lines from one label to the next.

            This is the number of contour bands between lines that are to be
            labeled::

                >>> from tecplot.constant import ContourType
                >>> plot.fieldmap(0).contour.contour_type = ContourType.Lines
                >>> plot.contour(0).labels.show = True
                >>> plot.contour(0).labels.step = 4
            """
            return self._get_style(int, sv.AUTOLEVELSKIP)

        @step.setter
        def step(self,value):
            self._set_style(int(value), sv.AUTOLEVELSKIP)

        @property
        def font(self):
            """`text.Font`: `text.Font` used to show the labels.

            Example::

                >>> from tecplot.constant import Color, ContourType
                >>> plot.fieldmap(0).contour.contour_type = ContourType.Lines
                >>> plot.contour(0).labels.show = True
                >>> plot.contour(0).labels.font.size = 3.5
            """
            return text.Font(self)

        @property
        def color(self):
            """`Color`: Text color of the labels.

            Example::

                >>> from tecplot.constant import Color, ContourType
                >>> plot.fieldmap(0).contour.contour_type = ContourType.Lines
                >>> plot.contour(0).labels.show = True
                >>> plot.contour(0).labels.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 filled(self):
            """`bool`: Fill the background area behind the text labels.

            The background can be filled with a color or disabled (made
            transparent) by setting this property to `False`::

                >>> from tecplot.constant import Color, ContourType
                >>> plot.fieldmap(0).contour.contour_type = ContourType.Lines
                >>> plot.contour(0).labels.show = True
                >>> plot.contour(0).labels.filled = True
                >>> plot.contour(0).labels.background_color = Color.Blue
                >>> plot.contour(1).labels.show = True
                >>> plot.contour(1).labels.filled = False
            """
            return self._get_style(bool, sv.ISFILLED)

        @filled.setter
        def filled(self, value):
            self._set_style(bool(value), sv.ISFILLED)

        @property
        def background_color(self):
            """`Color`: Background fill color behind the text labels.

            The ``filled`` attribute must be set to `True`::

                >>> from tecplot.constant import Color, ContourType
                >>> plot.fieldmap(0).contour.contour_type = ContourType.Lines
                >>> plot.contour(0).labels.show = True
                >>> plot.contour(0).labels.background_color = Color.Blue
            """
            return self._get_style(Color, sv.FILLCOLOR)
        @background_color.setter
        def background_color(self,value):
            self._set_style(Color(value), sv.FILLCOLOR)

        @property
        def auto_generate(self):
            """`bool`: Automatically generate labels along contour lines.

            This causes a new set of contour labels to be created at each redraw::

                >>> from tecplot.constant import Color, ContourType
                >>> plot.fieldmap(0).contour.contour_type = ContourType.Lines
                >>> plot.contour(0).labels.show = True
                >>> plot.contour(0).labels.auto_generate = True
            """
            return self._get_style(bool, sv.GENERATEAUTOLABELS)

        @auto_generate.setter
        def auto_generate(self,value):
            self._set_style(bool(value), sv.GENERATEAUTOLABELS)

        @property
        def label_by_level(self):
            """`bool`: Use the contour numbers as the label instead of the data value.

            Contour level numbers start from one when drawn. Example usage::

                >>> from tecplot.constant import Color, ContourType
                >>> plot.fieldmap(0).contour.contour_type = ContourType.Lines
                >>> plot.contour(0).labels.show = True
                >>> plot.contour(0).labels.label_by_level = True
            """
            return not self._get_style(bool, sv.LABELWITHVALUE)

        @label_by_level.setter
        def label_by_level(self,value):
            self._set_style(not bool(value), sv.LABELWITHVALUE)

        @property
        def margin(self):
            """`float` in percentage of the text height.: Spacing around the text and the filled background area.

            Contour numbers start from one when drawn. Example usage::

                >>> from tecplot.constant import Color, ContourType
                >>> plot.fieldmap(0).contour.contour_type = ContourType.Lines
                >>> plot.contour(0).labels.show = True
                >>> plot.contour(0).labels.background_color = Color.Yellow
                >>> plot.contour(0).labels.margin = 20
            """
            return self._get_style(float, sv.MARGIN)

        @margin.setter
        def margin(self,value):
            self._set_style(float(value), sv.MARGIN)

        @property
        def format(self):
            """`LabelFormat`: Number formatting for contour labels.

            Example usage::

                >>> from tecplot.constant import NumberFormat
                >>> contour = plot.contour(0)
                >>> contour.labels.format.format_type = NumberFormat.Integer
            """
            return text.LabelFormat(self)

    @lock_attributes
    class ContourLevels(object):
        """List of contour level values.

        A contour level is a value at which contour lines are drawn, or for banded
        contour flooding, the border between different colors of flooding.
        Initially, each contour group consists of approximately 10 levels evenly
        spaced over the *z* coordinate in the `Frame`'s `Dataset`. These values can
        be manipulated with the `ContourLevels` object obtained via the
        `ContourGroup.levels` attribute:

        .. code-block:: python
            :emphasize-lines: 11-12

            from os import path
            import numpy as np
            import tecplot as tp

            # load layout
            examples_dir = tp.session.tecplot_examples_directory()
            example_layout = path.join(examples_dir,'SimpleData','3ElementWing.lpk')
            tp.load_layout(example_layout)
            frame = tp.active_frame()

            levels = frame.plot().contour(0).levels
            levels.reset_levels(np.linspace(55000,115000,61))

            # save image to file
            tp.export.save_png('contour_adjusted_levels.png', 600, supersample=3)

        .. figure:: /_static/images/contour_adjusted_levels.png
            :width: 300px
            :figwidth: 300px

        .. note::

            The streamtraces in the plot above is a side-effect of settings in
            layout file used. For more information about streamtraces, see the
            `plot.Streamtraces` class reference.
        """
        def __init__(self, contour):
            self.contour = contour

        @lock()
        def _ContourLevelX(self, arglist):
            arglist[sv.CONTOURGROUP] = self.contour.index+1
            with self.contour.plot.frame.activated():
                _tecutil.ContourLevelX(arglist)

        def _data(self):
            with self.contour.plot.frame.activated():
                success,n,values = _tecutil.ContourGetLevels(self.contour.index+1)
                if not success:
                    raise TecplotLogicError('Could not query contour levels.')
                return [values[i] for i in range(n)]

        def __len__(self):
            return len(self._data())

        def __iter__(self):
            for i in self._data():
                yield i

        def __getitem__(self,i):
            return self._data()[i]

        def add(self, *values):
            """Adds new levels to the existing list.

            Parameters:
                *values (`floats <float>`): The level values to be added to the
                    `ContourGroup`.

            The values added are inserted into the list of levels in ascending
            order::

                >>> levels = plot.contour(0).levels
                >>> list(levels)
                [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
                >>> levels.add(3.14159)
                >>> list(levels)
                [0.0, 1.0, 2.0, 3.0, 3.14159, 4.0, 5.0]
            """
            values = flatten_args(*values)
            with tecutil.ArgList() as arglist:
                arglist[sv.CONTOURLEVELACTION] = ContourLevelAction.Add
                arglist[sv.NUMVALUES] = len(values)
                arglist[sv.RAWDATA] = map(float, values)
                self._ContourLevelX(arglist)

        def reset(self, num_levels=15):
            """Resets the levels to the number specified.

            Parameters:
                num_levels (`int`): Number of levels. (default: 10)

            This will reset the contour levels to a set of evenly
            distributed values spanning the entire range of the currently
            selected contouring variable::

                >>> plot.contour(0).levels.reset(30)
            """
            with tecutil.ArgList() as arglist:
                arglist[sv.CONTOURLEVELACTION] = ContourLevelAction.Reset
                arglist[sv.NUMVALUES] = int(num_levels)
                self._ContourLevelX(arglist)

        def reset_levels(self, *values):
            """Resets the levels to the values specified.

            Parameters:
                *values (`floats <float>`): The level values to be added to the
                    `ContourGroup`.

            This method replaces the current set of contour levels with a new set.
            Here, we set the levels to go from 0 to 100 in steps of 5::

                >>> plot.contour(0).levels.reset_levels(*range(0,101,5))
            """
            values = flatten_args(*values)
            with tecutil.ArgList() as arglist:
                arglist[sv.CONTOURLEVELACTION] = ContourLevelAction.New
                arglist[sv.NUMVALUES] = len(values)
                arglist[sv.RAWDATA] = map(float, values)
                self._ContourLevelX(arglist)

        def reset_to_nice(self, num_levels=15):
            """Approximately resets the levels to the number specified.

            Parameters:
                num_levels (`int`): Approximate number of levels to
                    create. (default: 15)

            This will reset the contour levels to a set of evenly distributed
            values that approximately spans the range of the currently selected
            contouring variable. Exact range and number of levels will be
            adjusted to make the contour levels have "nice" values::

                >>> plot.contour(0).levels.reset_to_nice(50)
            """
            with tecutil.ArgList() as arglist:
                arglist[sv.CONTOURLEVELACTION] = ContourLevelAction.ResetToNice
                arglist[sv.APPROXNUMVALUES] = int(num_levels)
                self._ContourLevelX(arglist)

        def delete_range(self, min_value, max_value):
            """Inclusively, deletes all levels within a specified range.

            Parameters:
                min_value (`float`): Minimum value to remove.
                max_value (`float`): Maximum value to remove.

            This method deletes all contour levels between the specified minimum
            and maximum values of the contour variable (inclusive)::

                >>> plot.contour(0).levels.delete_range(0.5, 1.5)
            """
            with tecutil.ArgList() as arglist:
                arglist[sv.CONTOURLEVELACTION] = ContourLevelAction.DeleteRange
                arglist[sv.RANGEMIN] = float(min_value)
                arglist[sv.RANGEMAX] = float(max_value)
                self._ContourLevelX(arglist)

        def delete_nearest(self, value):
            """Removes the level closest to the specified value.

            Parameters:
                value (`float`): Value of the level to remove.

            This method deletes the contour level with the value nearest the
            supplied value::

                >>> plot.contour(0).levels.delete_nearest(3.14)
            """
            with tecutil.ArgList() as arglist:
                arglist[sv.CONTOURLEVELACTION] = ContourLevelAction.DeleteNearest
                arglist[sv.RANGEMIN] = float(value)
                self._ContourLevelX(arglist)

    class ContourLines(ContourGroupStyle):
        """Contour line style.

        This object sets the style of the contour lines once turned on:

        .. code-block:: python
            :emphasize-lines: 19-22

            from os import path
            import tecplot as tp
            from tecplot.constant import (ContourLineMode, ContourType,
                                          SurfacesToPlot)

            # load the data
            examples_dir = tp.session.tecplot_examples_directory()
            datafile = path.join(examples_dir,'SimpleData','Pyramid.plt')
            dataset = tp.data.load_tecplot(datafile)

            # show boundary faces and contours
            plot = tp.active_frame().plot()
            plot.fieldmap(0).contour.contour_type = ContourType.Lines
            surfaces = plot.fieldmap(0).surfaces
            surfaces.surfaces_to_plot = SurfacesToPlot.BoundaryFaces
            plot.show_contour = True

            # set contour line style
            contour_lines = plot.contour(0).lines
            contour_lines.mode = ContourLineMode.SkipToSolid
            contour_lines.step = 4
            contour_lines.pattern_length = 2

            # ensure consistent output between interactive (connected) and batch
            plot.contour(0).levels.reset_to_nice()

            tp.export.save_png('contour_lines.png', 600, supersample=3)

        .. figure:: /_static/images/contour_lines.png
            :width: 300px
            :figwidth: 300px
        """
        def __init__(self, contour):
            self.contour = contour
            super().__init__(self.contour, sv.CONTOURLINESTYLE)

        @property
        def mode(self):
            """`ContourLineMode`: Type of lines to draw on the plot (`ContourLineMode`).

            Possible values:

                `UseZoneLineType`
                    For each zone, draw the contour lines using the line pattern
                    and pattern length specified in the `FieldmapContour` for the
                    parent `Fieldmap`. If you are adding contour lines to
                    polyhedral zones, the patterns will not be continuous from one
                    cell to the next and the pattern will restart at every cell
                    boundary.
                `SkipToSolid`
                    Draw dashed lines between each pair of solid lines which are
                    spaced out by the `ContourLines.step` property. This will
                    override any line pattern or thickness setting in the parent
                    `Fieldmap`'s `FieldmapContour` object.
                `DashNegative`
                    Draw lines of positive contour variable value as solid lines
                    and lines of negative contour variable value as dashed lines.
                    This will override any line pattern or thickness setting in the
                    parent `Fieldmap`'s `FieldmapContour` object.

            Example::

                >>> from tecplot.constant import ContourLineMode
                >>> lines = plot.contour(0).lines
                >>> lines.mode = ContourLineMode.DashNegative
            """
            return self._get_style(ContourLineMode, sv.CONTOURLINEMODE)

        @mode.setter
        def mode(self,value):
            self._set_style(ContourLineMode(value), sv.CONTOURLINEMODE)

        @property
        def step(self):
            """`int`: Number of lines to step for `SkipToSolid` line mode (`int`).

            Example::

                >>> from tecplot.constant import ContourLineMode
                >>> lines = plot.contour(0).lines
                >>> lines.mode = ContourLineMode.SkipToSolid
                >>> lines.step = 5
            """
            return self._get_style(int, sv.LINESKIP)

        @step.setter
        def step(self,value):
            self._set_style(int(value), sv.LINESKIP)

        @property
        def pattern_length(self):
            """`float`: Length of dashed lines and space between dashes (`float`).

            The length is in percentage of the frame height::

                >>> from tecplot.constant import ContourLineMode
                >>> lines = plot.contour(0).lines
                >>> lines.mode = ContourLineMode.SkipToSolid
                >>> lines.step = 5
                >>> lines.pattern_length = 5
            """
            return self._get_style(float, sv.PATTERNLENGTH)

        @pattern_length.setter
        def pattern_length(self,value):
            self._set_style(float(value), sv.PATTERNLENGTH)

    class ContourGroup(session.Style):
        """Contouring of a variable using a colormap.

        This object controls the style for a specific contour group within
        a `Frame`. Contour levels, colormap and contour lines are accessed
        through this class:

        .. code-block:: python
            :emphasize-lines: 10-14

            from os import path
            import tecplot as tp
            from tecplot.constant import *

            # load data
            examples_dir = tp.session.tecplot_examples_directory()
            datafile = path.join(examples_dir,'SimpleData','CircularContour.plt')
            dataset = tp.data.load_tecplot(datafile)
            plot = dataset.frame.plot()
            plot.show_contour = True

            contour = plot.contour(0)
            contour.variable = dataset.variable('Mix')
            contour.colormap_name = 'Magma'

            # ensure consistent output between interactive (connected) and batch
            contour.levels.reset_to_nice()

            # save image to file
            tp.export.save_png('contour_magma.png', 600, supersample=3)

        .. figure:: /_static/images/contour_magma.png
            :width: 300px
            :figwidth: 300px

        There are a fixed number of contour groups available for each plot. Others
        can be enabled and modified by specifying an index other than zero::

            >>> contour3 = plot.contour(3)
            >>> contour3.variable = dataset.variable('U')
        """
        def __init__(self, index, plot):
            if __debug__:
                assert 0 <= index < 8, 'Contour index out of range (must be < 8)'
            self.index = Index(index)
            self.plot = plot
            super().__init__(sv.GLOBALCONTOUR, uniqueid=self.plot.frame.uid,
                             offset1=self.index)

        def __eq__(self, obj):
            return (self.index == obj.index) and (self.plot == obj.plot)

        @property
        def variable_index(self):
            """Zero-based index of the `Variable` being contoured.

            .. code-block:: python

                >>> plot.contour(0).variable_index = dataset.variable('P').index

            The `Dataset` attached to this contour group's `Frame` is used::

                >>> contour = plot.contour(0)
                >>> contour_var = frame.dataset.variable(contour.variable_index)
                >>> contour_var.index == contour.variable_index
                True
            """
            return self._get_style(Index, sv.VAR)

        @variable_index.setter
        def variable_index(self, index):
            # Use the TecUtil X function to set the variable.
            # By using the X function to set the contour variable, we can set
            # the initialization mode to 'NiceResetLevels",
            # which is the GUI default.
            with lock():
                with tecutil.ArgList() as arglist:
                    arglist[sv.VAR] = index + 1
                    arglist[sv.CONTOURGROUP] = self.index + 1
                    arglist[sv.LEVELINITMODE] = \
                        ContourLevelsInitializationMode.NiceResetLevels
                    if not _tecutil.ContourSetVariableX(arglist):
                        raise TecplotSystemError()

        @property
        def variable(self):
            """The `Variable` being contoured.

            The variable must belong to the `Dataset` attached to the `Frame`
            that holds this `ContourGroup`. Example usage::

                >>> plot.contour(0).variable = dataset.variable('P')
            """
            return self.plot.frame.dataset.variable(self.variable_index)

        @variable.setter
        def variable(self, variable):
            if __debug__:
                if variable not in self.plot.frame.dataset:
                    raise TecplotLogicError('Variable not in dataset.')
            self.variable_index = variable.index

        @property
        def color_cutoff(self):
            """`ContourColorCutoff`: `ContourColorCutoff` object controlling color cutoff min/max.

            >>> cutoff = plot.contour(0).color_cutoff
            >>> cutoff.min = 3.14
            """
            return ContourColorCutoff(self)

        @property
        def colormap_filter(self):
            """`ContourColormapFilter`: `ContourColormapFilter` object controlling colormap style properties.

            >>> plot.contour(0).colormap_filter.reverse = True
            """
            return ContourColormapFilter(self)

        @property
        def labels(self):
            """`ContourLabels`: `ContourLabels` object controlling contour line labels.

            Lines must be turned on through the associated fieldmap object
            for style changes to be meaningful::

                >>> plot.fieldmap(0).contour.contour_type = ContourType.Lines
                >>> plot.contour(0).labels.show = True
            """
            return ContourLabels(self)

        @property
        def legend(self):
            """`ContourLegend`: `ContourLegend` associated with this `ContourGroup`.

            This object controls the attributes of the contour legend associated
            with this `ContourGroup`.

            Example usage::

                >>> plot.contour(0).legend.show = True
            """
            return legend.ContourLegend(self)

        @property
        def levels(self):
            """`ContourLevels`: `ContourLevels` holding the list of contour levels.

            This object controls the values of the contour levels. Values can
            be added, deleted or overridden completely::

                >>> plot.contour(0).levels.reset_to_nice(15)
            """
            return ContourLevels(self)

        @property
        def lines(self):
            """`ContourLines`: `ContourLines` object controlling contour line style.

            Lines must be turned on through the associated fieldmap object
            for style changes to be meaningful::

                >>> plot.fieldmap(0).contour.contour_type = ContourType.Lines
                >>> plot.contour(0).lines.mode = ContourLineMode.DashNegative
            """
            return ContourLines(self)

        @property
        def default_num_levels(self):
            """`int`: Default target number (`int`) of levels used when resetting.

            Example::

                >>> plot.contour(0).default_num_levels = 20
            """
            return self._get_style(int, sv.DEFNUMLEVELS)

        @default_num_levels.setter
        def default_num_levels(self, value):
            self._set_style(int(value), sv.DEFNUMLEVELS)

        @property
        def colormap_name(self):
            """`str`: The name of the colormap (`str`) to be used.

            Example::

                >>> plot.contour(0).colormap_name = 'Sequential - Yellow/Green/Blue'
            """
            return self._get_style(str, sv.COLORMAPNAME)

        @colormap_name.setter
        def colormap_name(self,value):
            self._set_style(str(value), sv.COLORMAPNAME)