# Source code for tecplot.export.animation

    import os
    import warnings

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

    from .export_setup import ExportSetup
    from .print_setup import PrintSetup

    class animation(object):
        r'''Frame-by-frame animation context.'''
        def __init__(self, filename, width=800, animation_speed=10,
                     region=ExportRegion.AllFrames, supersample=3,
                     compression=None, image_type=None,
                     multiple_color_tables=False, format_options=None,
                     convert_to_256_colors=None, jpeg_encoding=None, quality=None,
                     gray_scale_depth=None, tiff_byte_order=None, format=None):
            if __debug__:
                if compression is not None:
                    if (
                        format is ExportFormat.AVI and
                        version.sdk_version_info >= (2021, 2)
                    ):
                        msg = 'Compression option no longer supported for AVI'
                        msg += ' animations since ffmpeg is now used to assemble'
                        msg += ' AVI movies. Use the avi_format_options property'
                        msg += ' instead.'
                        warnings.warn(msg, TecplotDeprecationWarning)
                    elif format not in [ExportFormat.AVI, ExportFormat.Flash]:
                        msg = 'Compression only supported for AVI and Flash animations.'
                        msg += ' compression: {}   format: {}'.format(compression,
                                                                      format)
                        raise TecplotLogicError(msg)
                if (
                    image_type is not None and
                    format != ExportFormat.Flash
                ):
                    msg = 'Image-type only supported for Flash animations.'
                    raise TecplotLogicError(msg)
            _ext = {
                'avi': ExportFormat.AVI,
                'mp4': ExportFormat.MPEG4,
                'mpeg': ExportFormat.MPEG4,
                'f4v': ExportFormat.Flash,
                'flv': ExportFormat.Flash,
                'swf': ExportFormat.Flash,
                'rm': ExportFormat.RasterMetafile,
                'wmv': ExportFormat.WMV,

                # image formats
                'bmp': ExportFormat.BMP,
                'jpeg': ExportFormat.JPEG,
                'png': ExportFormat.PNG,
                'tiff': ExportFormat.TIFF,
            }
            if format is None:
                format = _ext.get(os.path.splitext(filename)[-1].split('.')[-1],
                                  ExportFormat.MPEG4)
            self.format = ExportFormat(format)

            self.filename = filename
            self.width = width
            self.animation_speed = animation_speed
            self.region = region
            self.supersample = supersample
            self.compression = compression
            self.image_type = image_type
            self.multiple_color_tables = multiple_color_tables
            self.format_options = format_options

            # image format options
            self.convert_to_256_colors = convert_to_256_colors
            self.jpeg_encoding = jpeg_encoding
            self.quality = quality
            self.gray_scale_depth = gray_scale_depth
            self.tiff_byte_order = tiff_byte_order

        @tecutil.lock()
        def setup(self):
            export_setup = ExportSetup()
            export_setup.reset()
            export_setup.format = self.format
            export_setup.filename = self.filename
            export_setup.width = self.width
            export_setup.animation_speed = self.animation_speed
            export_setup.region = self.region
            export_setup.supersample = self.supersample
            export_setup.multiple_color_tables = self.multiple_color_tables

            if self.format == ExportFormat.AVI:
                if version.sdk_version_info < (2021, 2):
                    export_setup.avi_compression = self.compression
                else:
                    export_setup.avi_format_options = self.format_options
            elif self.format == ExportFormat.Flash:
                export_setup.flash_compression = self.compression
                export_setup.flash_image_type = self.image_type
            elif self.format == ExportFormat.MPEG4:
                export_setup.mpeg_format_options = self.format_options
            elif self.format == ExportFormat.WMV:
                export_setup.wmv_format_options = self.format_options
            elif self.format in [ExportFormat.BMP, ExportFormat.PNG]:
                export_setup.convert_to_256_colors = self.convert_to_256_colors
            elif self.format == ExportFormat.JPEG:
                export_setup.jpeg_encoding = self.jpeg_encoding
                export_setup.quality = self.quality
            elif self.format == ExportFormat.TIFF:
                export_setup.gray_scale_depth = self.gray_scale_depth
                export_setup.tiff_byte_order = self.tiff_byte_order

        @tecutil.lock()
        def __enter__(self):
            self.setup()
            if not _tecutil.ExportStart():
                raise TecplotSystemError()
            return self

        @tecutil.lock()
        def __exit__(self, *args, **kargs):
            if not _tecutil.ExportFinish():
                raise TecplotSystemError()

        @tecutil.lock()
        def export_animation_frame(self):
            """Append a frame to the current animation.

            This function is available as a method on the object returned by the
            animation contexts:

                * `animation_avi`
                * `animation_flash`
                * `animation_mpeg4`
                * `animation_raster_metafile`
                * `animation_wmv`

            It instructs Tecplot 360 to capture the current state of the plot or
            workspace (see the *region* parameter in the contexts above) as a
            single frame in the resulting animation. Typical usage is to make small
            changes to the plot, calling `animation.export_animation_frame()` after
            each change to create a smooth transition from one view to another. For
            a detailed example, see `animation_mpeg4`. The following example is an
            excerpt from the MPEG-4 example code::

                with tp.export.animation_mpeg4(outfile, **opts) as ani:
                    for i in range(args.nframes):
                        view.rotate_axes(5, (1, 0, 0))
                        translate_view(view, 30 / args.nframes)
                        ani.export_animation_frame()
            """
            if not _tecutil.ExportNextFrame():
                raise TecplotSystemError()

    class animation_avi(animation):
        r'''Frame-by-frame AVI animation context.

        Parameters:
            filename (`str`): The resulting video file name or path, relative to
                Python's current working directory.
            width (`int`, optional): The width of the video in pixels. (default:
                800)
            animation_speed (`int`, optional): The frame-rate of the video in
                frames per second. (default: 10)
            region (`Frame` or `ExportRegion`, optional): The rectangular area to
                be exported. This can be a specific `Frame` object or one of
                `ExportRegion.CurrentFrame`, `ExportRegion.AllFrames` (default) or
                `ExportRegion.WorkArea`.
            supersample (`int`, optional): Controls the amount of anti-aliasing
                used in each frame. Valid values are 1-16. A value of **1**
                indicates that no antialiasing will be used. Antialiasing smooths
                jagged edges on text, lines, and edges of the video output by the
                process of supersampling. *Some graphics cards* can cause Tecplot
                360 to crash when larger anti-aliasing values are used. If this
                occurs on your machine, try updating your graphics driver or using
                a lower anti-aliasing value. (default: **3**)
            format_options (`str`, optional): A string of options passed directly
                to the underlying application `FFmpeg <https://www.ffmpeg.org/>`_.
                By default, this will be "-vcodec mjpeg -q:v 5".

        This is a `context manager
        <https://docs.python.org/3/reference/datamodel.html#context-managers>`_ and
        must be invoked using the `with
        <https://docs.python.org/3/reference/compound_stmts.html#with>`_ statement.
        The returned object of the context manager is used to control when each
        frame of the video is captured. This is done using the context method
        `animation.export_animation_frame()` as shown in the example below, at
        which point the specified region or plot is rendered. The actual video file
        is produced upon exit of the context.

        Typical code looks like the following (see the example under
        `animation_mpeg4` for a complete working example)::

            >>> with tp.export.animation_avi('output.avi') as ani:
            ...     # make some view changes here
            ...     ani.export_animation_frame()
        '''
        def __init__(self, filename, width=800, animation_speed=10,
                     region=ExportRegion.AllFrames, supersample=3,
                     compression=None, multiple_color_tables=False,
                     format_options=None):
            animation.__init__(self, filename=filename, width=width,
                               animation_speed=animation_speed, region=region,
                               supersample=supersample,
                               format_options=format_options,
                               compression=compression, # deprecated: use format_options instead
                               multiple_color_tables=multiple_color_tables, # deprecated: use format_options instead
                               format=ExportFormat.AVI)

    class animation_flash(animation):
        r'''Frame-by-frame Flash animation context.

        Parameters:
            filename (`str`): The resulting video file name or path, relative to
                Python's current working directory.
            width (`int`, optional): The width of the video in pixels. (default:
                800)
            animation_speed (`int`, optional): The frame-rate of the video in
                frames per second. (default: 10)
            region (`Frame` or `ExportRegion`, optional): The rectangular area to
                be exported. This can be a specific `Frame` object or one of
                `ExportRegion.CurrentFrame`, `ExportRegion.AllFrames` (default) or
                `ExportRegion.WorkArea`.
            supersample (`int`, optional): Controls the amount of anti-aliasing
                used in each frame. Valid values are 1-16. A value of **1**
                indicates that no antialiasing will be used. Antialiasing smooths
                jagged edges on text, lines, and edges of the video output by the
                process of supersampling. *Some graphics cards* can cause Tecplot
                360 to crash when larger anti-aliasing values are used. If this
                occurs on your machine, try updating your graphics driver or using
                a lower anti-aliasing value. (default: **3**)
            compression (`FlashCompressionType`, optional): The compression scheme
                to use when creating the video stream. Options are:
                `FlashCompressionType.BestSpeed` (default) and
                `FlashCompressionType.SmallestSize`.
            image_type (`FlashImageType`, optional): The type of images to generate
                for each frame of the animation. Options are:
                `FlashImageType.Color256`, `FlashImageType.JPEG` and
                `FlashImageType.Lossless` (default).

        This is a `context manager
        <https://docs.python.org/3/reference/datamodel.html#context-managers>`_ and
        must be invoked using the `with
        <https://docs.python.org/3/reference/compound_stmts.html#with>`_ statement.
        The returned object of the context manager is used to control when each
        frame of the video is captured. This is done using the context method
        `animation.export_animation_frame()` as shown in the example below, at
        which point the specified region or plot is rendered. The actual video file
        is produced upon exit of the context.

        Typical code looks like the following (see the example under
        `animation_mpeg4` for a complete working example)::

            >>> with tp.export.animation_flash('output.flv') as ani:
            ...     # make some view changes here
            ...     ani.export_animation_frame()
        '''
        def __init__(self, filename, width=800, animation_speed=10,
                     region=ExportRegion.AllFrames, supersample=3,
                     compression=None, image_type=FlashImageType.Lossless):
            animation.__init__(self, filename=filename, width=width,
                               animation_speed=animation_speed, region=region,
                               supersample=supersample, compression=compression,
                               image_type=image_type, format=ExportFormat.Flash)

    class animation_mpeg4(animation):
        r'''Frame-by-frame MPEG4 animation context.

        Parameters:
            filename (`str`): The resulting video file name or path, relative to
                Python's current working directory.
            width (`int`, optional): The width of the video in pixels. (default:
                800)
            animation_speed (`int`, optional): The frame-rate of the video in
                frames per second. (default: 10)
            region (`Frame` or `ExportRegion`, optional): The rectangular area to
                be exported. This can be a specific `Frame` object or one of
                `ExportRegion.CurrentFrame`, `ExportRegion.AllFrames` (default) or
                `ExportRegion.WorkArea`.
            supersample (`int`, optional): Controls the amount of anti-aliasing
                used in each frame. Valid values are 1-16. A value of **1**
                indicates that no antialiasing will be used. Antialiasing smooths
                jagged edges on text, lines, and edges of the video output by the
                process of supersampling. *Some graphics cards* can cause Tecplot
                360 to crash when larger anti-aliasing values are used. If this
                occurs on your machine, try updating your graphics driver or using
                a lower anti-aliasing value. (default: **3**)
            format_options (`str`, optional): A string of options passed directly
                to the underlying application `FFmpeg <https://www.ffmpeg.org/>`_.
                By default, this will be "-c:v libx264 -profile:v high -crf 20
                -pix_fmt yuv420p".

        This is a `context manager
        <https://docs.python.org/3/reference/datamodel.html#context-managers>`_ and
        must be invoked using the `with
        <https://docs.python.org/3/reference/compound_stmts.html#with>`_ statement.
        The returned object of the context manager is used to control when each
        frame of the video is captured. This is done using the context method
        `animation.export_animation_frame()` as shown in the example below, at
        which point the specified region or plot is rendered. The actual video file
        is produced upon exit of the context.

        Example usage:

        .. code-block:: python
            :emphasize-lines: 64,68

            import argparse, os

            import tecplot as tp
            from tecplot.constant import *

            def parse_args():
                """
                This script is to be run from the command line and accepts the
                following command line arguments. Run this script with "--help"
                to see usage and help information.
                """
                parser = argparse.ArgumentParser()
                parser.add_argument('-c', '--connect', action='store_true',
                                    help='connect to TecUtil Server')
                parser.add_argument('-p', '--port', type=int, default=7600,
                                    help='port to use when connecting to TecUtil Server')
                parser.add_argument('-n', '--nframes', type=int, default=360,
                                    help='number of frames to produce in video')
                parser.add_argument('outfile', nargs='?', default='aileron_roll.mp4',
                                    help='output file name')
                return parser.parse_args()

            def setup_plot():
                """
                Load the F-18 dataset from Tecplot 360's examples and show the
                jet surface in 3D.
                """
                tp.new_layout()
                exdir = tp.session.tecplot_examples_directory()
                datafile = os.path.join(exdir, 'SimpleData', 'F18.plt')
                ds = tp.data.load_tecplot(datafile)

                frame = tp.active_frame()
                frame.show_border = False
                plot = frame.plot(PlotType.Cartesian3D)
                plot.activate()

                plot.contour(0).variable = ds.variable('S')
                plot.show_contour = True
                return plot

            def translate_view(view, x=0, y=0, z=0):
                """
                Translate the viewer with respect to the data.
                """
                p = view.position
                view.position = p.x + x, p.y + y, p.z + z

            def create_animation(outfile, plot, nframes):
                """
                Using the tp.export.animation_mpeg4() context manager, the F-18 is
                recorded doing an "aileron roll" by rotating and translating the
                viewer with respect to the data by a small amount and capturing
                each frame of the animation with a call to ani.export_animation_frame()
                """
                with tp.session.suspend():
                    opts = dict(
                        width=400,
                        animation_speed=30,
                        supersample=3,
                    )
                    view = plot.view
                    translate_view(view, -15)
                    with tp.export.animation_mpeg4(outfile, **opts) as ani:
                      for i in range(args.nframes):
                        view.rotate_axes(5, (1, 0, 0))
                        translate_view(view, 30 / args.nframes)
                        ani.export_animation_frame()

            """
            This script is meant to run on the command line. Run with "--help" to see
            usage and help information about the options it understands. It loads
            the F-18 dataset from Tecplot 360's examples directory and produces a
            video of the model doing an "aileron roll" by manipulating the viewer
            position.
            """
            args = parse_args()
            if args.connect:
                tp.session.connect(port=args.port)
            plot = setup_plot()
            create_animation(args.outfile, plot, args.nframes)
            print('video file created:', args.outfile)

        .. raw:: html

            <video controls>
                <source src="../_static/videos/aileron_roll.m4v" type="video/mp4">
                I'm sorry; your browser doesn't support HTML5 MPEG4/H.264 video.
            </video>
        '''
        def __init__(self, filename, width=800, animation_speed=10,
                     region=ExportRegion.AllFrames, supersample=3,
                     format_options=None):
            animation.__init__(self, filename=filename, width=width,
                               animation_speed=animation_speed, region=region,
                               supersample=supersample,
                               format_options=format_options,
                               format=ExportFormat.MPEG4)

    class animation_raster_metafile(animation):
        r'''Frame-by-frame Raster Metafile animation context.

        Parameters:
            filename (`str`): The resulting video file name or path, relative to
                Python's current working directory.
            width (`int`, optional): The width of the video in pixels. (default:
                800)
            animation_speed (`int`, optional): The frame-rate of the video in
                frames per second. (default: 10)
            region (`Frame` or `ExportRegion`, optional): The rectangular area to
                be exported. This can be a specific `Frame` object or one of
                `ExportRegion.CurrentFrame`, `ExportRegion.AllFrames` (default) or
                `ExportRegion.WorkArea`.
            supersample (`int`, optional): Controls the amount of anti-aliasing
                used in each frame. Valid values are 1-16. A value of **1**
                indicates that no antialiasing will be used. Antialiasing smooths
                jagged edges on text, lines, and edges of the video output by the
                process of supersampling. *Some graphics cards* can cause Tecplot
                360 to crash when larger anti-aliasing values are used. If this
                occurs on your machine, try updating your graphics driver or using
                a lower anti-aliasing value. (default: **3**)
            multiple_color_tables (`bool`, optional): Create a color table for each
                frame of the animation. If `False` (default), the whole animation
                will be scanned in an attempt to create a single table of 256
                colors.

        This is a `context manager
        <https://docs.python.org/3/reference/datamodel.html#context-managers>`_ and
        must be invoked using the `with
        <https://docs.python.org/3/reference/compound_stmts.html#with>`_ statement.
        The returned object of the context manager is used to control when each
        frame of the video is captured. This is done using the context method
        `animation.export_animation_frame()` as shown in the example below, at
        which point the specified region or plot is rendered. The actual video file
        is produced upon exit of the context.

        Typical code looks like the following (see the example under
        `animation_mpeg4` for a complete working example)::

            >>> with tp.export.animation_raster_metafile('output.rm') as ani:
            ...     # make some view changes here
            ...     ani.export_animation_frame()
        '''
        def __init__(self, filename, width=800, animation_speed=10,
                     region=ExportRegion.AllFrames, supersample=3,
                     multiple_color_tables=False):
            animation.__init__(self, filename=filename, width=width,
                               animation_speed=animation_speed, region=region,
                               supersample=supersample,
                               multiple_color_tables=multiple_color_tables,
                               format=ExportFormat.RasterMetafile)

    class animation_wmv(animation):
        r'''Frame-by-frame WMV animation context.

        Parameters:
            filename (`str`): The resulting video file name or path, relative to
                Python's current working directory.
            width (`int`, optional): The width of the video in pixels. (default:
                800)
            animation_speed (`int`, optional): The frame-rate of the video in
                frames per second. (default: 10)
            region (`Frame` or `ExportRegion`, optional): The rectangular area to
                be exported. This can be a specific `Frame` object or one of
                `ExportRegion.CurrentFrame`, `ExportRegion.AllFrames` (default) or
                `ExportRegion.WorkArea`.
            supersample (`int`, optional): Controls the amount of anti-aliasing
                used in each frame. Valid values are 1-16. A value of **1**
                indicates that no antialiasing will be used. Antialiasing smooths
                jagged edges on text, lines, and edges of the video output by the
                process of supersampling. *Some graphics cards* can cause Tecplot
                360 to crash when larger anti-aliasing values are used. If this
                occurs on your machine, try updating your graphics driver or using
                a lower anti-aliasing value. (default: **3**)
            format_options (`str`, optional): A string of options passed directly
                to the underlying application `FFmpeg <https://www.ffmpeg.org/>`_.
                By default, this will be "-qscale 4".

        This is a `context manager
        <https://docs.python.org/3/reference/datamodel.html#context-managers>`_ and
        must be invoked using the `with
        <https://docs.python.org/3/reference/compound_stmts.html#with>`_ statement.
        The returned object of the context manager is used to control when each
        frame of the video is captured. This is done using the context method
        `animation.export_animation_frame()` as shown in the example below, at
        which point the specified region or plot is rendered. The actual video file
        is produced upon exit of the context.

        Typical code looks like the following (see the example under
        `animation_mpeg4` for a complete working example)::

            >>> with tp.export.animation_wmv('output.wmv') as ani:
            ...     # make some view changes here
            ...     ani.export_animation_frame()
        '''
        def __init__(self, filename, width=800, animation_speed=10,
                     region=ExportRegion.AllFrames, supersample=3,
                     format_options=None):
            animation.__init__(self, filename=filename, width=width,
                               animation_speed=animation_speed, region=region,
                               supersample=supersample,
                               format_options=format_options,
                               format=ExportFormat.WMV)