pytecplot 1.5.2__py3-none-any.whl

tecplot/annotation/geometry.py

@@ -0,0 +1,369 @@
+from ..tecutil import _tecutil
+from .. import constant, tecutil
+from . import annotation
+
+
+class Geometry(annotation.Annotation):
+    """Base class for all geometric shape annotations."""
+    @property
+    def color(self):
+        """`Color`: Line `Color`.
+
+        This example shows how to change the edge or line `Color` to red::
+
+            >>> from tecplot.constant import Color, CoordSys
+            >>> geom = frame.add_circle((50, 50), 10, CoordSys.Frame)
+            >>> geom.color = Color.Red
+        """
+        return constant.Color(_tecutil.GeomGetColor(self.uid))
+
+    @color.setter
+    @tecutil.lock()
+    def color(self, value):
+        with self.frame.activated():
+            _tecutil.GeomSetColor(self.uid, constant.Color(value).value)
+
+    @property
+    def fill_color(self):
+        """`constant.Color`: Background fill color.
+
+        This example shows how to change the area fill `Color` to red. To turn
+        off filling the geometry, set this attribute to `None`::
+
+            >>> from tecplot.constant import Color, CoordSys
+            >>> geom = frame.add_circle((50, 50), 10, CoordSys.Frame)
+            >>> geom.fill_color = Color.Red
+        """
+        with self.frame.activated():
+            is_filled = _tecutil.GeomGetIsFilled(self.uid)
+            if is_filled:
+                return constant.Color(_tecutil.GeomGetFillColor(self.uid))
+
+    @fill_color.setter
+    @tecutil.lock()
+    def fill_color(self, value):
+        with self.frame.activated():
+            if value is None:
+                _tecutil.GeomSetIsFilled(self.uid, False)
+            else:
+                _tecutil.GeomSetIsFilled(self.uid, True)
+                _tecutil.GeomSetFillColor(self.uid, constant.Color(value).value)
+
+    @property
+    def line_pattern(self):
+        """`LinePattern`: Pattern used for drawing lines or edges.
+
+        This example shows how to change the line pattern::
+
+            >>> from tecplot.constant import CoordSys, LinePattern
+            >>> geom = frame.add_circle((50, 50), 10, CoordSys.Frame)
+            >>> geom.line_pattern = LinePattern.DashDot
+        """
+        with self.frame.activated():
+            return constant.LinePattern(_tecutil.GeomGetLinePattern(self.uid))
+
+    @line_pattern.setter
+    @tecutil.lock()
+    def line_pattern(self, value):
+        with self.frame.activated():
+            line_pattern = constant.LinePattern(value)
+            _tecutil.GeomSetLinePattern(self.uid, line_pattern.value)
+
+    @property
+    def line_thickness(self):
+        """`float`: Thickness of lines or edges.
+
+        This example shows how to change the line thickness::
+
+            >>> from tecplot.constant import CoordSys
+            >>> geom = frame.add_circle((50, 50), 10, CoordSys.Frame)
+            >>> geom.line_thickness = 4.0
+        """
+        with self.frame.activated():
+            return _tecutil.GeomGetLineThickness(self.uid)
+
+    @line_thickness.setter
+    @tecutil.lock()
+    def line_thickness(self, value):
+        with self.frame.activated():
+            _tecutil.GeomSetLineThickness(self.uid, float(value))
+
+    @property
+    def pattern_length(self):
+        """`float`: Length of the line pattern.
+
+        This example shows how to change the pattern length::
+
+            >>> from tecplot.constant import CoordSys
+            >>> geom = frame.add_circle((50, 50), 10, CoordSys.Frame)
+            >>> geom.pattern_length = 1.2
+        """
+        with self.frame.activated():
+            return _tecutil.GeomGetPatternLength(self.uid)
+
+    @pattern_length.setter
+    @tecutil.lock()
+    def pattern_length(self, value):
+        with self.frame.activated():
+            _tecutil.GeomSetPatternLength(self.uid, float(value))
+
+
+class Geometry2D(Geometry, annotation.MovableAnnotation):
+    @property
+    def clipping(self):
+        """`Clipping`: Clip geometry to the axes or frame for 2D plots.
+
+        Clipping refers to displaying only that portion of an object that falls
+        within a specified clipping region of the plot. If you have specified
+        the position in the Frame coordinate system, the `Annotation` will be
+        clipped to the frame. Default: `Clipping.ClipToViewport`.
+
+        If you have specified the Grid coordinate system, you can choose to
+        clip your `Annotation` to the frame or the viewport. The size of the
+        viewport depends on the plot type as follows:
+
+            * 3D Cartesian - The viewport is the same as the frame, so viewport
+                clipping is the same as frame clipping.
+            * 2D Cartesian/XY Line - The viewport is defined by the extents of
+                the X and Y axes.
+            * Polar Line/Sketch - By default, the viewport is the same as the
+                frame.
+
+        .. warning::
+
+            For 3D and line plots the viewport is the same as the frame and so
+            clipping to the viewport or the frame will have no apparent affect.
+            In cartesian 2D plots, clipping to the axes
+            (`Clipping.ClipToViewport`) is only available when the position
+            coordinate system is `CoordSys.Grid`.
+
+        Example of clipping a circle to the frame::
+
+            >>> from tecplot.constant import Clipping, CoordSys
+            >>> geom = frame.add_circle((0.5, 0.5), 0.55, CoordSys.Grid)
+            >>> geom.clipping = Clipping.ClipToFrame
+        """
+        with self.frame.activated():
+            return constant.Clipping(_tecutil.GeomGetClipping(self.uid))
+
+    @clipping.setter
+    @tecutil.lock()
+    def clipping(self, value):
+        with self.frame.activated():
+            _tecutil.GeomSetClipping(self.uid, constant.Clipping(value).value)
+
+
+class CurvedGeometry(Geometry2D):
+    @property
+    def num_points(self):
+        """`int`: Number of points to use when creating the curved shape.
+
+        This is the number of segments along the edge plus one. Example usage::
+
+            >>> from tecplot.constant import CoordSys
+            >>> geom = frame.add_circle((50, 50), 10, CoordSys.Frame)
+            >>> geom.num_points = 300
+        """
+        with self.frame.activated():
+            return _tecutil.GeomEllipseGetNumPoints(self.uid)
+
+    @num_points.setter
+    @tecutil.lock()
+    def num_points(self, value):
+        _tecutil.GeomEllipseSetNumPoints(self.uid, int(value))
+
+
+class Circle(CurvedGeometry):
+    """A circle annotation attached to a `Frame <layout.Frame>`.
+
+    .. seealso:: `Frame.add_circle()`
+
+    .. code-block:: python
+
+        import tecplot as tp
+        from tecplot.constant import *
+
+        frame = tp.active_frame()
+
+        circle0 = frame.add_circle((40, 50), 12, CoordSys.Frame)
+        circle1 = frame.add_circle((50, 50), 12, CoordSys.Frame)
+        circle2 = frame.add_circle((60, 50), 12, CoordSys.Frame)
+
+        circle0.fill_color = Color.Magenta
+        circle1.fill_color = Color.Yellow
+        circle2.fill_color = Color.Cyan
+
+        tp.export.save_png('circle.png', 600)
+
+    .. figure:: /_static/images/circle.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    @property
+    def radius(self):
+        """`float`: Length of the radius.
+
+        This will be in the coordinate system specified by
+        `Circle.position_coordinate_system`. This example creates a circle of
+        radius 5 and then doubles it to 10 later::
+
+            >>> from tecplot.constant import CoordSys
+            >>> geom = frame.add_circle((20, 30), 5, CoordSys.Frame)
+            >>> geom.radius = 10
+        """
+        with self.frame.activated():
+            return _tecutil.GeomCircleGetRadius(self.uid)
+
+    @radius.setter
+    @tecutil.lock()
+    def radius(self, value):
+        with self.frame.activated():
+            _tecutil.GeomCircleSetRadius(self.uid, float(value))
+
+
+class Ellipse(CurvedGeometry):
+    """An ellipse annotation attached to a `Frame <layout.Frame>`.
+
+    .. seealso:: `Frame.add_ellipse()`
+
+    .. code-block:: python
+
+        import tecplot as tp
+        from tecplot.constant import *
+
+        frame = tp.active_frame()
+
+        ellipse0 = frame.add_ellipse((40, 45), (10, 12), CoordSys.Frame)
+        ellipse1 = frame.add_ellipse((50, 50), (10, 16), CoordSys.Frame)
+        ellipse2 = frame.add_ellipse((60, 55), (10, 20), CoordSys.Frame)
+
+        ellipse0.fill_color = Color.Magenta
+        ellipse1.fill_color = Color.Yellow
+        ellipse2.fill_color = Color.Cyan
+
+        tp.export.save_png('ellipse.png', 600)
+
+    .. figure:: /_static/images/ellipse.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    @property
+    def size(self):
+        """`tuple`: Size :math:`(h_{axis}, v_{axis})` of the ellipse.
+
+        This is the horizontal and vertical axis lengths of the ellipse and
+        will be in the coordinate system specified by
+        `Ellipse.position_coordinate_system`. This example creates an ellipse
+        with :math:`(h_{axis}, v_{axis})` of :math:`(5, 10)` and changes it to
+        :math:`(10, 20)` later::
+
+            >>> from tecplot.constant import CoordSys
+            >>> geom = frame.add_ellipse((50, 50), (5, 10), CoordSys.Frame)
+            >>> geom.size = (10, 20)
+        """
+        with self.frame.activated():
+            return _tecutil.GeomEllipseGetSize(self.uid)
+
+    @size.setter
+    @tecutil.lock()
+    def size(self, values):
+        haxis, vaxis = (float(v) for v in values)
+        _tecutil.GeomEllipseSetSize(self.uid, haxis, vaxis)
+
+
+class Rectangle(Geometry2D):
+    """A rectangle annotation attached to a `Frame <layout.Frame>`.
+
+    .. seealso:: `Frame.add_rectangle()`
+
+    .. code-block:: python
+
+        import tecplot as tp
+        from tecplot.constant import *
+
+        frame = tp.active_frame()
+
+        rectangle0 = frame.add_rectangle((40, 45), (20, 12), CoordSys.Frame)
+        rectangle1 = frame.add_rectangle((50, 50), (20, 16), CoordSys.Frame)
+        rectangle2 = frame.add_rectangle((60, 55), (20, 20), CoordSys.Frame)
+
+        rectangle0.fill_color = Color.Magenta
+        rectangle1.fill_color = Color.Yellow
+        rectangle2.fill_color = Color.Cyan
+
+        tp.export.save_png('rectangle.png', 600)
+
+    .. figure:: /_static/images/rectangle.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    @property
+    def size(self):
+        """`tuple`: Size :math:`(width, height)` of the rectangle.
+
+        This is the width and height of the rectangle and will be in the
+        coordinate system specified by `Rectangle.position_coordinate_system`.
+        This example creates a rectangle with :math:`(width, height)` of
+        :math:`(5, 10)` and changes it to :math:`(10, 20)` later::
+
+            >>> from tecplot.constant import CoordSys
+            >>> geom = frame.add_rectangle((50, 50), (5, 10), CoordSys.Frame)
+            >>> geom.size = (10, 20)
+        """
+        with self.frame.activated():
+            return _tecutil.GeomRectangleGetSize(self.uid)
+
+    @size.setter
+    @tecutil.lock()
+    def size(self, values):
+        width, height = (float(v) for v in values)
+        with self.frame.activated():
+            _tecutil.GeomRectangleSetSize(self.uid, width, height)
+
+
+class Square(Geometry2D):
+    """A square annotation attached to a `Frame <layout.Frame>`.
+
+    .. seealso:: `Frame.add_square()`
+
+    .. code-block:: python
+
+        import tecplot as tp
+        from tecplot.constant import *
+
+        frame = tp.active_frame()
+
+        square0 = frame.add_square((40, 40), 15, CoordSys.Frame)
+        square1 = frame.add_square((50, 50), 15, CoordSys.Frame)
+        square2 = frame.add_square((60, 60), 15, CoordSys.Frame)
+
+        square0.fill_color = Color.Magenta
+        square1.fill_color = Color.Yellow
+        square2.fill_color = Color.Cyan
+
+        tp.export.save_png('square.png', 600)
+
+    .. figure:: /_static/images/square.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    @property
+    def size(self):
+        """`float`: Length of one side of the square.
+
+        This will be in the coordinate system specified by
+        `Square.position_coordinate_system`. This example creates a square of
+        side-length 5 and then doubles it to 10 later::
+
+            >>> from tecplot.constant import CoordSys
+            >>> geom = frame.add_square((50, 50), 5, CoordSys.Frame)
+            >>> geom.radius = 10
+        """
+        with self.frame.activated():
+            return _tecutil.GeomSquareGetSize(self.uid)
+
+    @size.setter
+    @tecutil.lock()
+    def size(self, value):
+        with self.frame.activated():
+            _tecutil.GeomSquareSetSize(self.uid, float(value))

tecplot/annotation/georeference.py

@@ -0,0 +1,33 @@
+from ..tecutil import _tecutil
+from ..exception import *
+from .. import tecutil
+from . import annotation
+
+
+class GeoreferencedImage(annotation.Annotation):
+    """A Geographic reference image.
+
+    A georeferenced can be added to a plot with a call to
+    `Frame.add_georeferenced_image()`. Placement of the image is controlled by
+    the :math:`(x, y)` variables of the `Frame <layout.Frame>` and the `GeoreferencedImage`
+    object's :math:`z` parameter.
+    """
+    @property
+    def z(self):
+        """`float`: :math:`z`-position of the georeferenced image.
+
+        This is the :math:`z` position (typically elevation) of the
+        georeferenced image with respect to the :math:`(x, y, z)` variables set
+        in the `Frame <layout.Frame>`. Example usage::
+
+            >>> georefimg.z = 100
+        """
+        with self.frame.activated():
+            pos = _tecutil.GeomGetAnchorPos(self.uid)
+            return tecutil.XYZ(*pos).z
+
+    @z.setter
+    @tecutil.lock()
+    def z(self, value):
+        with self.frame.activated():
+            _tecutil.GeomSetAnchorPos(self.uid, 0, 0, float(value))

tecplot/annotation/image.py

@@ -0,0 +1,185 @@
+from ..tecutil import _tecutil
+from ..exception import *
+from .. import constant, tecutil
+
+from .annotation import MovableAnnotation
+
+
+class Image(MovableAnnotation):
+    """Image annotation.
+
+    This example shows creating an image from a 2D plot and overlaying it on
+    the 3D plot of the same data.
+
+    .. code-block:: python
+        :emphasize-lines: 22
+
+        import os
+
+        import tecplot as tp
+        from tecplot.constant import PlotType
+
+        examples_dir = tp.session.tecplot_examples_directory()
+        datafile = os.path.join(examples_dir, 'SimpleData', 'F18.plt')
+        dataset = tp.data.load_tecplot(datafile)
+
+        frame = tp.active_frame()
+
+        plot2d = frame.plot(PlotType.Cartesian2D)
+        plot2d.activate()
+        plot2d.show_contour = True
+        plot2d.contour(0).colormap_name = 'Sequential - Blue'
+        plot2d.contour(0).variable = dataset.variable('S')
+        tp.export.save_png('embedded_image.png')
+
+        plot3d = frame.plot(PlotType.Cartesian3D)
+        plot3d.activate()
+        plot3d.show_contour = True
+        frame.add_image('embedded_image.png', (5, 55), 40)
+
+        tp.export.save_png('image.png')
+
+    .. figure:: /_static/images/image.png
+        :width: 300px
+        :figwidth: 300px
+    """
+    @property
+    def filename(self):
+        """`str`: Source file (read-only).
+
+        Example usage::
+
+            >>> image = frame.add_imge('my_image.png', (20, 20), 40)
+            >>> print(image.filename)
+            my_image.png
+        """
+        with self.frame.activated():
+            return _tecutil.GeomImageGetFileName(self.uid)
+
+    @property
+    def height(self):
+        """`float`: Displayed image height in the coordinate system specified.
+
+        The units for height are determined by the `position_coordinate_system`
+        of the image. This example sets the height to 40% of the `Frame <layout.Frame>`::
+
+            >>> from tecplot.constant import CoordSys
+            >>> image.position_coordinate_system = CoordSys.Frame
+            >>> image.height = 40
+        """
+        return self.size[1]
+
+    @height.setter
+    @tecutil.lock()
+    def height(self, value):
+        value = float(value)
+        if value <= 0.0:
+            msg = 'Annotation image height must be greater than 0'
+            raise TecplotValueError(msg)
+        with self.frame.activated():
+            _tecutil.GeomImageSetHeight(self.uid, value)
+
+    @property
+    def maintain_aspect_ratio(self):
+        """`bool`: Keep aspect ratio on width or height change.
+
+        Example usage::
+
+            >>> image.maintain_aspect_ratio = True
+        """
+        with self.frame.activated():
+            return _tecutil.GeomImageGetUseRatio(self.uid)
+
+    @maintain_aspect_ratio.setter
+    @tecutil.lock()
+    def maintain_aspect_ratio(self, value):
+        with self.frame.activated():
+            _tecutil.GeomImageSetUseRatio(self.uid, bool(value))
+
+    @property
+    def raw_size(self):
+        """:math:`(width, height)`: Original image size in pixels (read-only).
+
+        Example usage::
+
+            >>> print(image.raw_size)
+            (600, 400)
+        """
+        return _tecutil.GeomImageGetRawSize(self.uid)
+
+    @tecutil.lock()
+    def reset_aspect_ratio(self):
+        """Restore the aspect ratio to that of the original image.
+
+        Example usage::
+
+            >>> image.reset_aspect_ratio()
+        """
+        _tecutil.GeomImageResetAspectRatio(self.uid)
+
+    @property
+    def resize_filter(self):
+        """`ImageResizeFilter`: Smoothing filter.
+
+        Possible values are `ImageResizeFilter.Texture`,
+        `ImageResizeFilter.Box`, `ImageResizeFilter.Lanczos2`,
+        `ImageResizeFilter.Lanczos3`, `ImageResizeFilter.Triangle`,
+        `ImageResizeFilter.Bell`, `ImageResizeFilter.BSpline`,
+        `ImageResizeFilter.Cubic`, `ImageResizeFilter.Mitchell`,
+        `ImageResizeFilter.Gaussian`. Example usage::
+
+            >>> from tecplot.constant import ImageResizeFilter
+            >>> image.resize_filter = ImageResizeFilter.BSpline
+        """
+        imgrf = _tecutil.GeomImageGetResizeFilter(self.uid)
+        with self.frame.activated():
+            return constant.ImageResizeFilter(imgrf)
+
+    @resize_filter.setter
+    @tecutil.lock()
+    def resize_filter(self, value):
+        imgrf = constant.ImageResizeFilter(value)
+        with self.frame.activated():
+            _tecutil.GeomImageSetResizeFilter(self.uid, imgrf.value)
+
+    @property
+    def size(self):
+        """:math:`(width, height)`: Displayed image size.
+
+        This will be in the coordinates specified by
+        `Image.position_coordinate_system`. Example usage::
+
+            >>> image.size = (40, 20)
+        """
+        with self.frame.activated():
+            return _tecutil.GeomImageGetSize(self.uid)
+
+    @size.setter
+    def size(self, values):
+        width, height = (float(v) for v in values)
+        _maintain_aspect = self.maintain_aspect_ratio
+        if _maintain_aspect:
+            self.maintain_aspect_ratio = False
+        self.width = width
+        self.height = height
+        if _maintain_aspect:
+            self.maintain_aspect_ratio = _maintain_aspect
+
+    @property
+    def width(self):
+        """`float`: Displayed image width in the coordinate system specified.
+
+        The units for width are determined by the `position_coordinate_system`
+        of the image. This example sets the width to 40% of the `Frame <layout.Frame>`::
+
+            >>> from tecplot.constant import CoordSys
+            >>> image.position_coordinate_system = CoordSys.Frame
+            >>> image.width = 0.4
+        """
+        return self.size[0]
+
+    @width.setter
+    @tecutil.lock()
+    def width(self, value):
+        with self.frame.activated():
+            _tecutil.GeomImageSetWidth(self.uid, float(value))

tecplot/annotation/iter.py

@@ -0,0 +1,105 @@
+from ..tecutil import _tecutil
+from .. import constant
+from .annotation import Annotation, MovableAnnotation
+from .geometry import Circle, Ellipse, Rectangle, Square
+from .georeference import GeoreferencedImage
+from .image import Image
+from .polyline import MultiPolyline2D, MultiPolyline3D, Polyline2D, Polyline3D
+from .text import Text
+
+class GeometryIterator(object):
+    """
+        type_filter is a function that takes a Geometry object and returns one
+        of the concrete geometry objects: Circle, Square, Polyline3D,
+        MultiPolyline2D, Image, etc. or None if the object is to be filtered
+        out. For convenience, this class provides static methods for geometric
+        shape and image filtering.
+    """
+    def __init__(self, type_filter, frame):
+        self.type_filter = type_filter
+        self.frame = frame
+
+    def __iter__(self):
+        self.current_item = None
+        return self
+
+    @staticmethod
+    def ShapeFilter(anno):
+        geom_type = anno.type
+        if geom_type == constant.GeomType.LineSegs:
+            anno = MovableAnnotation(anno.uid, anno.frame)
+            if anno.position_coordinate_system == constant.CoordSys.Grid3D:
+                mpolyline = MultiPolyline3D(anno.uid, anno.frame)
+                if len(mpolyline) == 1:
+                    return Polyline3D(0, mpolyline)
+                else:
+                    return mpolyline
+            else:
+                mpolyline = MultiPolyline2D(anno.uid, anno.frame)
+                if len(mpolyline) == 1:
+                    return Polyline2D(0, mpolyline)
+                else:
+                    return mpolyline
+        else:
+            try:
+                ShapeTypes = {
+                    constant.GeomType.Circle: Circle,
+                    constant.GeomType.Ellipse: Ellipse,
+                    constant.GeomType.Rectangle: Rectangle,
+                    constant.GeomType.Square: Square,
+                }
+                return ShapeTypes[geom_type](anno.uid, anno.frame)
+            except KeyError:
+                return
+
+    @staticmethod
+    def ImageFilter(anno):
+        if anno.type == constant.GeomType.Image:
+            anno = MovableAnnotation(anno.uid, anno.frame)
+            if anno.position_coordinate_system == constant.CoordSys.Grid3D:
+                return GeoreferencedImage(anno.uid, anno.frame)
+            else:
+                return Image(anno.uid, anno.frame)
+
+    def __next__(self):
+        with self.frame.activated():
+            while True:
+                if getattr(self, 'current_item', None) is None:
+                    uid = _tecutil.GeomGetBase()
+                else:
+                    uid = _tecutil.GeomGetNext(self.current_item.uid)
+                if not uid:
+                    break
+                self.current_item = Annotation(uid, self.frame)
+                obj = self.type_filter(self.current_item)
+                if obj is None:
+                    continue
+                self.current_item = obj
+                return self.current_item
+        raise StopIteration
+
+    def next(self):
+        return self.__next__()
+
+
+class TextIterator(object):
+    def __init__(self, frame):
+        self.frame = frame
+
+    def __iter__(self):
+        self.current_item = None
+        return self
+
+    def __next__(self):
+        with self.frame.activated():
+            if getattr(self, 'current_item', None) is None:
+                uid = _tecutil.TextGetBase()
+            else:
+                uid = _tecutil.TextGetNext(self.current_item.uid)
+        if not uid:
+            raise StopIteration
+        self.current_item = Text(uid, self.frame)
+        return self.current_item
+
+    def next(self):
+        return self.__next__()