sketchingpy.transform

  1"""Data structures providing transformation matrix functionality if native logic is not available.
  2
  3Data structures providing Python-based transformation matrix functionality if native logic is not
  4available in the underlying renderer.
  5
  6License:
  7    BSD
  8"""
  9
 10import math
 11import typing
 12
 13has_numpy = False
 14try:
 15    import numpy
 16    has_numpy = True
 17except:
 18    pass
 19
 20
 21class TransformedPoint:
 22    """A point which has gone through zero or more transformations."""
 23
 24    def __init__(self, x: float, y: float, scale: float, rotation: float):
 25        """Create a new transformed point.
 26
 27        Args:
 28            x: Horizontal coordinate for this point after transformation.
 29            y: Vertical coordinate for this point after transformation.
 30            scale: The overall scale factor applied to this point.
 31            rotation: The overall rotation applied to this point.
 32        """
 33        self._x = x
 34        self._y = y
 35        self._scale = scale
 36        self._rotation = rotation
 37
 38    def get_x(self) -> float:
 39        """Get the post-transformation x coordinate.
 40
 41        Returns:
 42            Horizontal coordinate for this point after transformation.
 43        """
 44        return self._x
 45
 46    def get_y(self) -> float:
 47        """Get the post-transformation y coordinate.
 48
 49        Returns:
 50            Vertical coordinate for this point after transformation.
 51        """
 52        return self._y
 53
 54    def get_scale(self) -> float:
 55        """Get the overall scale reflected in this point.
 56
 57        Returns:
 58            The overall scale factor applied to this point.
 59        """
 60        return self._scale
 61
 62    def get_rotation(self) -> float:
 63        """Get the overall rotation reflected in this point.
 64
 65        Returns:
 66            The overall rotation factor applied to this point.
 67        """
 68        return self._rotation
 69
 70
 71class Transformer:
 72    """Utility to transform points."""
 73
 74    def __init__(self, matrix: typing.Optional['numpy.ndarray'] = None, scale: float = 1,
 75        rotation: float = 0):
 76        """Create a new transformer.
 77
 78        Args:
 79            matrix: Starting transformation matrix.
 80            scale: Starting overall scale.
 81            rotation: Starting overall rotation.
 82        """
 83
 84        if not has_numpy:
 85            raise RuntimeError('Need numpy in order to use transformer on this renderer.')
 86
 87        matrix_unset = matrix is None
 88        scale_unset = abs(scale - 1) < 0.00001
 89        rotation_unset = abs(rotation - 0) < 0.00001
 90
 91        self._is_default = matrix_unset and scale_unset and rotation_unset
 92        self._matrix = numpy.identity(3) if matrix is None else matrix
 93        self._scale = scale
 94        self._rotation = rotation
 95
 96    def translate(self, x: float, y: float):
 97        """Apply a translation to the current transformation matrix.
 98
 99        Args:
100            x: By how much to offset the horizontal coordinate.
101            y: By how much to offset the vertical coordinate.
102        """
103        transformation = numpy.identity(3)
104        transformation[0][2] = x
105        transformation[1][2] = y
106        self._matrix = numpy.dot(self._matrix, transformation)
107        self._is_default = False
108
109    def scale(self, scale: float):
110        """Apply a scale to the current transformation matrix.
111
112        Args:
113            scale: The scale to apply.
114        """
115        transformation = numpy.identity(3)
116        transformation[0][0] = scale
117        transformation[1][1] = scale
118        self._matrix = numpy.dot(self._matrix, transformation)
119        self._scale *= scale
120        self._is_default = False
121
122    def rotate(self, angle: float):
123        """Apply a rotation to the current transforation matrix counter-clockwise.
124
125        Args:
126            angle: The angle of rotation to apply as radians.
127        """
128        cos_angle = math.cos(angle)
129        sin_angle = math.sin(angle)
130
131        transformation = numpy.identity(3)
132        transformation[0][0] = cos_angle
133        transformation[1][1] = cos_angle
134        transformation[1][0] = -1 * sin_angle
135        transformation[0][1] = sin_angle
136
137        self._matrix = numpy.dot(self._matrix, transformation)
138        self._rotation += angle
139        self._is_default = False
140
141    def transform(self, x: float, y: float) -> TransformedPoint:
142        """Transform a point.
143
144        Args:
145            x: The horizontal coordinate to be transformed.
146            y: The vertical coordinate to be transformed.
147
148        Returns:
149            Point after transformation.
150        """
151        if self._is_default:
152            return TransformedPoint(x, y, self._scale, self._rotation)
153
154        input_array = numpy.array([x, y, 1])
155        output = numpy.dot(self._matrix, input_array)
156
157        x = output[0]
158        y = output[1]
159
160        return TransformedPoint(x, y, self._scale, self._rotation)
161
162    def quick_copy(self) -> 'Transformer':
163        """Create a shallow copy of this transformer.
164
165        Returns:
166            Transformer which has the same transform matrix as this original transformer.
167        """
168        return Transformer(self._matrix, self._scale, self._rotation)