thorvg-python 1.0.1__py3-none-win32.whl

thorvg_python/gradient/__init__.py

@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+import ctypes
+from typing import Optional, Sequence, Tuple, cast
+
+from ..base import (
+    ColorStop,
+    GradientStruct,
+    Identifier,
+    Matrix,
+    Result,
+    StrokeFill,
+    TvgType,
+)
+from ..engine import Engine
+
+
+class Gradient:
+    """
+    Common Gradient API
+
+    A module managing the gradient fill of objects.
+
+    The module enables to set and to get the gradient colors and their arrangement inside the gradient bounds,
+    to specify the gradient bounds and the gradient behavior in case the area defined by the gradient bounds
+    is smaller than the area to be filled.
+
+    This is base Gradient class. Please use LinearGradient or RadialGradient for creating
+    """
+
+    def __init__(self, engine: Engine, grad: GradientStruct):
+        self.engine = engine
+        self.thorvg_lib = engine.thorvg_lib
+        self._grad = grad
+
+    def set_color_stops(
+        self,
+        color_stop: Sequence[ColorStop],
+    ) -> Result:
+        """Sets the parameters of the colors of the gradient and their position.
+
+        :param Sequence[ColorStop] color_stop: An array of ColorStop data structure.
+
+        :return: INVALID_ARGUMENT An invalid GradientStruct pointer.
+        :rtype: Result
+        """
+        color_stop_arr_type = ColorStop * len(color_stop)
+        self.thorvg_lib.tvg_gradient_set_color_stops.argtypes = [
+            ctypes.POINTER(GradientStruct),
+            ctypes.POINTER(color_stop_arr_type),
+            ctypes.c_uint32,
+        ]
+        self.thorvg_lib.tvg_gradient_set_color_stops.restype = Result
+        return self.thorvg_lib.tvg_gradient_set_color_stops(
+            ctypes.pointer(self._grad),
+            ctypes.pointer(color_stop_arr_type(*color_stop)),
+            ctypes.c_uint32(len(color_stop)),
+        )
+
+    def get_color_stops(
+        self,
+    ) -> Tuple[Result, Sequence[ColorStop]]:
+        """Gets the parameters of the colors of the gradient, their position and number
+
+        The function does not allocate any memory.
+
+        :return: INVALID_ARGUMENT A ``nullptr`` passed as the argument.
+        :rtype: Result
+        :return: An array of ColorStop data structure.
+        :rtype: Sequence[ColorStop]
+        """
+        color_stop_ptr = ctypes.POINTER(ColorStop)()
+        cnt = ctypes.c_uint32()
+        self.thorvg_lib.tvg_gradient_get_color_stops.argtypes = [
+            ctypes.POINTER(GradientStruct),
+            ctypes.POINTER(ctypes.POINTER(ColorStop)),
+            ctypes.POINTER(ctypes.c_uint32),
+        ]
+        self.thorvg_lib.tvg_gradient_get_color_stops.restype = Result
+        result = self.thorvg_lib.tvg_gradient_get_color_stops(
+            ctypes.pointer(self._grad),
+            ctypes.pointer(color_stop_ptr),
+            ctypes.pointer(cnt),
+        )
+        color_stop_type = ColorStop * cnt.value
+        color_stop_arr = color_stop_type.from_address(
+            ctypes.addressof(color_stop_ptr.contents)
+        )
+        return result, [color_stop_arr[i] for i in range(cnt.value)]
+
+    def set_spread(
+        self,
+        spread: StrokeFill,
+    ) -> Result:
+        """Sets the StrokeFill value, which specifies how to fill the area outside the gradient bounds.
+
+        :param StrokeFill spread: The FillSpread value.
+
+        :return: INVALID_ARGUMENT An invalid GradientStruct pointer.
+        :rtype: Result
+        """
+        self.thorvg_lib.tvg_gradient_set_spread.argtypes = [
+            ctypes.POINTER(GradientStruct),
+            ctypes.c_int,
+        ]
+        self.thorvg_lib.tvg_gradient_set_spread.restype = Result
+        return self.thorvg_lib.tvg_gradient_set_spread(
+            ctypes.pointer(self._grad),
+            spread,
+        )
+
+    def get_spread(self) -> Tuple[Result, StrokeFill]:
+        """Gets the FillSpread value of the gradient object.
+
+        :return: INVALID_ARGUMENT A ``nullptr`` passed as the argument.
+        :rtype: Result
+        :return: The FillSpread value.
+        :rtype: StrokeFill
+        """
+        spread = ctypes.c_int()
+        self.thorvg_lib.tvg_gradient_get_spread.argtypes = [
+            ctypes.POINTER(GradientStruct),
+            ctypes.POINTER(ctypes.c_int),
+        ]
+        self.thorvg_lib.tvg_gradient_get_spread.restype = Result
+        result = self.thorvg_lib.tvg_gradient_get_spread(
+            ctypes.pointer(self._grad),
+            ctypes.pointer(spread),
+        )
+        return result, StrokeFill(spread.value)
+
+    def set_transform(self, m: Matrix) -> Result:
+        """Sets the matrix of the affine transformation for the gradient object.
+
+        The augmented matrix of the transformation is expected to be given.
+
+        :param Matrix m The 3x3 augmented matrix.
+
+        :return: INVALID_ARGUMENT A ``nullptr`` is passed as the argument.
+        :rtype: Result
+        """
+        self.thorvg_lib.tvg_gradient_set_transform.argtypes = [
+            ctypes.POINTER(GradientStruct),
+            ctypes.POINTER(Matrix),
+        ]
+        self.thorvg_lib.tvg_gradient_set_transform.restype = Result
+        return self.thorvg_lib.tvg_gradient_set_transform(
+            ctypes.pointer(self._grad),
+            ctypes.pointer(m),
+        )
+
+    def get_transform(self) -> Tuple[Result, Matrix]:
+        """Gets the matrix of the affine transformation of the gradient object.
+
+        In case no transformation was applied, the identity matrix is set.
+
+        :return: INVALID_ARGUMENT A ``nullptr`` is passed as the argument.
+        :rtype: Result
+        :return: The 3x3 augmented matrix.
+        :rtype: Matrix
+        """
+        m = Matrix()
+        self.thorvg_lib.tvg_gradient_get_transform.argtypes = [
+            ctypes.POINTER(GradientStruct),
+            ctypes.POINTER(Matrix),
+        ]
+        self.thorvg_lib.tvg_gradient_get_transform.restype = Result
+        result = self.thorvg_lib.tvg_gradient_get_transform(
+            ctypes.pointer(self._grad),
+            ctypes.pointer(m),
+        )
+        return result, m
+
+    def get_type(self) -> Tuple[Result, TvgType]:
+        """Gets the unique value of the gradient instance indicating the instance type.
+
+        :return: INVALID_ARGUMENT In case a ``nullptr`` is passed as the argument.
+        :rtype: Result
+        :return: The unique type of the gradient instance type.
+        :rtype: TvgType
+
+        .. note::
+            Experimental API
+        """
+        _type = ctypes.c_int()
+        self.thorvg_lib.tvg_gradient_get_type.argtypes = [
+            ctypes.POINTER(GradientStruct),
+            ctypes.POINTER(ctypes.c_int),
+        ]
+        self.thorvg_lib.tvg_gradient_get_type.restype = Result
+        result = self.thorvg_lib.tvg_gradient_get_type(
+            ctypes.pointer(self._grad),
+            ctypes.pointer(_type),
+        )
+        return result, TvgType(_type.value)
+
+    def get_identifier(self) -> Tuple[Result, Identifier]:
+        """
+        .. deprecated:: 0.15
+        .. seealso:: Gradient.get_type()
+        """
+        identifier = ctypes.c_int()
+        self.thorvg_lib.tvg_gradient_get_identifier.argtypes = [
+            ctypes.POINTER(GradientStruct),
+            ctypes.POINTER(ctypes.c_int),
+        ]
+        self.thorvg_lib.tvg_gradient_get_identifier.restype = Result
+        result = self.thorvg_lib.tvg_gradient_get_identifier(
+            ctypes.pointer(self._grad),
+            ctypes.pointer(identifier),
+        )
+        return result, Identifier(identifier.value)
+
+    def duplicate(self) -> Optional["Gradient"]:
+        """Duplicates the given GradientStruct object.
+
+        Creates a new object and sets its all properties as in the original object.
+
+        :return: A copied GradientStruct object if succeed, ``None`` otherwise.
+        :rtype: GradientStruct
+        """
+        self.thorvg_lib.tvg_gradient_duplicate.argtypes = [
+            ctypes.POINTER(GradientStruct)
+        ]
+        self.thorvg_lib.tvg_gradient_duplicate.restype = ctypes.POINTER(GradientStruct)
+        tvg_gradient = cast(
+            GradientStruct,
+            self.thorvg_lib.tvg_gradient_duplicate(ctypes.pointer(self._grad)).contents,
+        )
+        if type(self).__name__ == "LinearGradient":
+            from .linear import LinearGradient
+
+            return LinearGradient(self.engine, tvg_gradient)
+        elif type(self).__name__ == "RadialGradient":
+            from .radial import RadialGradient
+
+            return RadialGradient(self.engine, tvg_gradient)
+        else:
+            raise TypeError(f"Unknown Gradient class {type(self).__name__}")
+
+    def _del(self) -> Result:
+        """Deletes the given gradient object.
+
+        :return: INVALID_ARGUMENT An invalid GradientStruct pointer.
+        :rtype: Result
+        """
+        self.thorvg_lib.tvg_gradient_del.argtypes = [ctypes.POINTER(GradientStruct)]
+        self.thorvg_lib.tvg_gradient_del.restype = Result
+        return self.thorvg_lib.tvg_gradient_del(ctypes.pointer(self._grad))

thorvg_python/gradient/linear.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+import ctypes
+from typing import Optional, Tuple
+
+from ..base import GradientStruct, Result
+from ..engine import Engine
+from . import Gradient
+
+
+class LinearGradient(Gradient):
+    """
+    Linear Gradient API
+    """
+
+    def __init__(self, engine: Engine, grad: Optional[GradientStruct] = None):
+        self.engine = engine
+        self.thorvg_lib = engine.thorvg_lib
+        if grad is None:
+            self._grad = self._new()
+        else:
+            self._grad = grad
+
+    def _new(self) -> GradientStruct:
+        """Creates a new linear gradient object.
+
+        Note that you need not call this method as it is auto called when initializing ``LinearGradient()``.
+
+        .. code-block:: python
+
+            from thorvg_python import Engine, Shape, LinearGradient, ColorStop
+
+            engine = Engine()
+            shape = Shape(engine)
+            shape.append_rect(700, 700, 100, 100, 20, 20)
+            grad = LinearGradient(engine)
+            grad.set(700, 700, 800, 800)
+            color_stops = [
+                ColorStop(0.0, 0, 0,   0, 255),
+                ColorStop(1.0, 0, 255, 0, 255),
+            ]
+            grad.set_color_stops(color_stops, 2)
+            shape.set_linear_gradient(grad)
+
+        :return: A new linear gradient object.
+        :rtype: GradientStruct
+        """
+        self.thorvg_lib.tvg_linear_gradient_new.restype = ctypes.POINTER(GradientStruct)
+        return self.thorvg_lib.tvg_linear_gradient_new().contents
+
+    def set(
+        self,
+        x1: float,
+        y1: float,
+        x2: float,
+        y2: float,
+    ) -> Result:
+        """Sets the linear gradient bounds.
+
+        The bounds of the linear gradient are defined as a surface constrained by two parallel lines crossing
+        the given points (``x1``, ``y1``) and (``x2``, ``y2``), respectively. Both lines are perpendicular to the line linking
+        (``x1``, ``y1``) and (``x2``, ``y2``).
+
+        :param float x1: The horizontal coordinate of the first point used to determine the gradient bounds.
+        :param float y1: The vertical coordinate of the first point used to determine the gradient bounds.
+        :param float x2: The horizontal coordinate of the second point used to determine the gradient bounds.
+        :param float y2: The vertical coordinate of the second point used to determine the gradient bounds.
+
+        :return: INVALID_ARGUMENT An invalid GradientStruct pointer.
+        :rtype: Result
+
+        .. note::
+            In case the first and the second points are equal, an object is filled with a single color using the last color specified in the tvg_gradient_set_color_stops().
+        .. seealso:: Gradient.set_color_stops()
+        """
+        self.thorvg_lib.tvg_linear_gradient_set.argtypes = [
+            ctypes.POINTER(GradientStruct),
+            ctypes.c_float,
+            ctypes.c_float,
+            ctypes.c_float,
+            ctypes.c_float,
+        ]
+        self.thorvg_lib.tvg_linear_gradient_set.restype = Result
+        return self.thorvg_lib.tvg_linear_gradient_set(
+            ctypes.pointer(self._grad),
+            ctypes.c_float(x1),
+            ctypes.c_float(y1),
+            ctypes.c_float(x2),
+            ctypes.c_float(y2),
+        )
+
+    def get(
+        self,
+    ) -> Tuple[Result, float, float, float, float]:
+        """Gets the linear gradient bounds.
+
+        The bounds of the linear gradient are defined as a surface constrained by two parallel lines crossing
+        the given points (``x1``, ``y1``) and (``x2``, ``y2``), respectively. Both lines are perpendicular to the line linking
+        (``x1``, ``y1``) and (``x2``, ``y2``).
+
+        :return: INVALID_ARGUMENT An invalid GradientStruct pointer.
+        :rtype: Result
+        :return: The horizontal coordinate of the first point used to determine the gradient bounds.
+        :rtype: float
+        :return: The vertical coordinate of the first point used to determine the gradient bounds.
+        :rtype: float
+        :return: The horizontal coordinate of the second point used to determine the gradient bounds.
+        :rtype: float
+        :return: The vertical coordinate of the second point used to determine the gradient bounds.
+        :rtype: float
+        """
+        x1 = ctypes.c_float()
+        y1 = ctypes.c_float()
+        x2 = ctypes.c_float()
+        y2 = ctypes.c_float()
+        self.thorvg_lib.tvg_linear_gradient_get.argtypes = [
+            ctypes.POINTER(GradientStruct),
+            ctypes.POINTER(ctypes.c_float),
+            ctypes.POINTER(ctypes.c_float),
+            ctypes.POINTER(ctypes.c_float),
+            ctypes.POINTER(ctypes.c_float),
+        ]
+        self.thorvg_lib.tvg_linear_gradient_get.restype = Result
+        result = self.thorvg_lib.tvg_linear_gradient_get(
+            ctypes.pointer(self._grad),
+            ctypes.pointer(x1),
+            ctypes.pointer(y1),
+            ctypes.pointer(x2),
+            ctypes.pointer(y2),
+        )
+        return result, x1.value, y1.value, x2.value, y2.value

thorvg_python/gradient/radial.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+import ctypes
+from typing import Optional, Tuple
+
+from ..base import GradientStruct, Result
+from ..engine import Engine
+from . import Gradient
+
+
+class RadialGradient(Gradient):
+    """
+    Radial Gradient API
+    """
+
+    def __init__(self, engine: Engine, grad: Optional[GradientStruct] = None):
+        self.engine = engine
+        self.thorvg_lib = engine.thorvg_lib
+        if grad is None:
+            self._grad = self._new()
+        else:
+            self._grad = grad
+
+    def _new(self) -> GradientStruct:
+        """Creates a new radial gradient object.
+
+        Note that you need not call this method as it is auto called when initializing ``RadialGradient()``.
+
+        .. code-block:: python
+
+            from thorvg_python import Engine, Shape, RadialGradient, Tvg_ColorStop
+
+            engine = Engine()
+            shape = Shape(engine)
+            shape.append_rect(700, 700, 100, 100, 20, 20)
+            grad = RadialGradient(engine)
+            grad.set(550, 550, 50)
+            color_stops =
+            [
+                ColorStop(0.0, 0, 0,   0, 255),
+                ColorStop(1.0, 0, 255, 0, 255),
+            ]
+            grad.set_color_stops(color_stops, 2)
+            shape.set_radial_gradient(grad)
+
+        :return: A new radial gradient object.
+        :rtype: GradientStruct
+        """
+        self.thorvg_lib.tvg_radial_gradient_new.restype = ctypes.POINTER(GradientStruct)
+        return self.thorvg_lib.tvg_radial_gradient_new().contents
+
+    def set(
+        self,
+        cx: float,
+        cy: float,
+        radius: float,
+    ) -> Result:
+        """Sets the radial gradient bounds.
+
+        The radial gradient bounds are defined as a circle centered in a given point (``cx``, ``cy``) of a given radius.
+
+        :param float cx: The horizontal coordinate of the center of the bounding circle.
+        :param float cy: The vertical coordinate of the center of the bounding circle.
+        :param float radius: The radius of the bounding circle.
+
+        :return: INVALID_ARGUMENT An invalid GradientStruct pointer or the ``radius`` value less than zero.
+        :rtype: Result
+
+        .. note::
+            In case the ``radius`` is zero, an object is filled with a single color using the last color specified in the specified in the tvg_gradient_set_color_stops().
+        .. seealso:: Gradient.set_color_stops()
+        """
+        self.thorvg_lib.tvg_radial_gradient_set.argtypes = [
+            ctypes.POINTER(GradientStruct),
+            ctypes.c_float,
+            ctypes.c_float,
+            ctypes.c_float,
+        ]
+        self.thorvg_lib.tvg_radial_gradient_set.restype = Result
+        return self.thorvg_lib.tvg_radial_gradient_set(
+            ctypes.pointer(self._grad),
+            ctypes.c_float(cx),
+            ctypes.c_float(cy),
+            ctypes.c_float(radius),
+        )
+
+    def get(self) -> Tuple[Result, float, float, float]:
+        """The function gets radial gradient center point ant radius
+
+        :return: INVALID_ARGUMENT An invalid GradientStruct pointer.
+        :rtype: Result
+        :return: The horizontal coordinate of the center of the bounding circle.
+        :rtype: float
+        :return: The vertical coordinate of the center of the bounding circle.
+        :rtype: float
+        :return: The radius of the bounding circle.
+        :rtype: float
+        """
+        cx = ctypes.c_float()
+        cy = ctypes.c_float()
+        radius = ctypes.c_float()
+        self.thorvg_lib.tvg_radial_gradient_get.argtypes = [
+            ctypes.POINTER(GradientStruct),
+            ctypes.POINTER(ctypes.c_float),
+            ctypes.POINTER(ctypes.c_float),
+            ctypes.POINTER(ctypes.c_float),
+        ]
+        self.thorvg_lib.tvg_radial_gradient_get.restype = Result
+        result = self.thorvg_lib.tvg_radial_gradient_get(
+            ctypes.pointer(self._grad),
+            ctypes.pointer(cx),
+            ctypes.pointer(cy),
+            ctypes.pointer(radius),
+        )
+        return result, cx.value, cy.value, radius.value