simetri.graphics.pattern

  1from math import prod
  2from itertools import product
  3from dataclasses import dataclass
  4from hashlib import md5
  5
  6import numpy as np
  7from typing_extensions import Union, Self
  8
  9from .shape import Shape
 10from .batch import Batch
 11from .affine import *
 12from .common import Point, Line, common_properties
 13from .all_enums import Types, get_enum_value, Anchor
 14from .core import StyleMixin
 15from .bbox import bounding_box, BoundingBox
 16from ..canvas.style_map import ShapeStyle, shape_style_map, shape_args
 17from ..helpers.validation import validate_args
 18from ..geometry.geometry import homogenize
 19
 20@dataclass
 21class Transform:
 22    """
 23    A class representing a single transformation.
 24    Used in the Transformation class to represent a transformation matrix and its repetitions.
 25
 26    Attributes:
 27        xform_matrix (ndarray): The transformation matrix.
 28        reps (int): The number of repetitions of the transformation.
 29    """
 30
 31    xform_matrix: 'ndarray'
 32    _reps: int = 0
 33
 34    def __post_init__(self):
 35        self.type = Types.TRANSFORM
 36        self.subtype = Types.TRANSFORM
 37        common_properties(self, graphics_object=False, id_only=True)
 38        self.__dict__['_xform_matrix'] = self.xform_matrix
 39        # self.__dict__['_reps'] = self.reps
 40        self._update()
 41
 42    def _update(self):
 43        self.hash = md5(self.xform_matrix.tobytes()).hexdigest()
 44        self._set_partitions()
 45        self._composite = np.concatenate(self.partitions, axis=1)
 46
 47    @property
 48    def reps(self) -> int:
 49        return self._reps
 50
 51    @reps.setter
 52    def reps(self, value: int):
 53        if value < 0:
 54            raise ValueError("x cannot be negative")
 55        self._reps = value
 56
 57
 58    def _changed(self):
 59        """
 60        Checks if the transformation matrix has changed.
 61
 62        Returns:
 63            bool: True if the transformation matrix has changed, False otherwise.
 64        """
 65        return not((self.hash == md5(self.xform_matrix.tobytes()).hexdigest()) and
 66                (self.reps == self._reps))
 67
 68    def _set_partitions(self):
 69        if self.reps == 0:
 70            partition_list = [identity_matrix()]
 71        elif self.reps == 1:
 72            partition_list = [identity_matrix(), self.xform_matrix]
 73        else:
 74            xform_mat = self.xform_matrix
 75            partition_list = [identity_matrix(), xform_mat]
 76            last = xform_mat
 77            for _ in range(self._reps-1):
 78                last = xform_mat @ last
 79                partition_list.append(last)
 80
 81        self._partitions = partition_list
 82
 83    def update(self):
 84        self._set_partitions()
 85        self._composite = np.concatenate(self.partitions, axis=1)
 86        self.hash = md5(self._composition.tobytes()).hexdigest()
 87
 88    @property
 89    def xform_matrix(self) -> 'ndarray':
 90        """
 91        Returns the transformation matrix.
 92
 93        Returns:
 94            ndarray: The transformation matrix.
 95        """
 96
 97        return self._xform_matrix
 98
 99    @xform_matrix.setter
100    def xform_matrix(self, value: 'ndarray'):
101        if not isinstance(value, np.ndarray):
102            raise ValueError("xform_matrix must be a numpy array")
103        self._xform_matrix = value
104        self._update()
105
106    @property
107    def partitions(self) -> list:
108        """
109        Returns the submatrices in the transformation.
110
111        Returns:
112            list: A list of submatrices.
113        """
114        if self._changed():
115            self.update()
116
117        return self._partitions
118
119    @partitions.setter
120    def partitions(self, value: list):
121        raise AttributeError(("Cannot set partitions directly. "
122                             "Use the update method to update the partitions."))
123
124    @property
125    def composite(self) -> 'ndarray':
126        """
127        Returns the compound transformation matrix.
128
129        Returns:
130            ndarray: The compound transformation matrix.
131        """
132        if self._changed():
133            self.update()
134
135        return self._composite
136
137    @composite.setter
138    def composite(self, value: 'ndarray'):
139        raise AttributeError(("Cannot set composition directly. "
140                              "Use the update method to update the composition."))
141
142    def copy(self) -> 'Tranform':
143        """
144        Creates a copy of the Transform instance.
145
146        Returns:
147            Transform: A new Transform instance with the same attributes.
148        """
149        return Transform(self.xform_matrix.copy(), self.reps)
150
151@dataclass
152class Transformation:
153    """
154    A class representing a transformation that can be composite or not.
155
156    Attributes:
157        transforms (list): A list of Transform instances representing the transformations.
158    """
159
160    components: list=None
161
162    def __post_init__(self):
163        self.type = Types.TRANSFORMATION
164        self.subtype = Types.TRANSFORMATION
165        if self.components is None:
166            self.components = []
167        common_properties(self, graphics_object=False, id_only=True)
168
169    @property
170    def partitions(self) -> list:
171        """
172        Returns the submatrices in the transformation.
173
174        Returns:
175            list of ndarrays.
176        """
177        if len(self.components) == 0:
178            return [identity_matrix()]
179        elif len(self.components) == 1:
180            partitions = [identity_matrix(), self.components[0].xform_matrix]
181        else:
182            partitions = []
183            for component in self.components:
184                partitions.extend(component.partitions)
185
186        return partitions
187
188    @property
189    def composite(self) -> 'ndarray':
190        """
191        Returns the compound transformation matrix.
192
193        Returns:
194            ndarray: The compound transformation matrix.
195        """
196        if len(self.components) == 0:
197            return identity_matrix()
198        matrices = []
199        for component in self.components:
200            matrices.append(component.partitions)
201        res = []
202        if len(matrices) == 1:
203            if len(matrices[0]) == 1:
204                return matrices[0][0]
205            else:
206                return np.concatenate(matrices[0], axis=1)
207        else:
208            for mats in product(*matrices):
209                res.append(np.linalg.multi_dot(mats))
210
211        return np.concatenate(res, axis=1)
212
213    @composite.setter
214    def composite(self, value: 'ndarray'):
215        raise AttributeError(("Cannot set composition directly. "
216                              "Use the update method to update the composition."))
217
218
219    def copy(self) -> 'Transformation':
220        """
221        Creates a copy of the Transform instance.
222
223        Returns:
224            Transform: A new Transform instance with the same components.
225        """
226        return Transformation([component.copy() for component in self.components])
227
228class Pattern(Batch, StyleMixin):
229    """
230    A class representing a pattern of a shape or batch object.
231
232    Attributes:
233        kernel (Shape/Batch): The repeated form.
234        transformation: A Transformation object.
235    """
236
237    def __init__(self, kernel: Union[Shape, Batch]=None, transformation:Transformation=None, **kwargs):
238        """
239        Initializes the Pattern instance with a pattern and its count.
240
241        Args:
242            kernel (Shape/Batch): The repeated form of the pattern.
243            transformation (Transformation): The transformation applied to the pattern.
244            **kwargs: Additional keyword arguments.
245        """
246        self.__dict__["style"] = ShapeStyle()
247        self.__dict__["_style_map"] = shape_style_map
248        self._set_aliases()
249        self.kernel = kernel
250        if transformation is None:
251            transformation = Transformation()
252
253        self.transformation = transformation
254        super().__init__(**kwargs)
255        self.subtype = Types.PATTERN
256        common_properties(self)
257
258        valid_args = shape_args
259        validate_args(kwargs, valid_args)
260
261    @property
262    def closed(self) -> bool:
263        """
264        Returns True if the pattern is closed.
265
266        Returns:
267            bool: True if the pattern is closed, False otherwise.
268        """
269        return self.kernel.closed
270
271    @closed.setter
272    def closed(self, value: bool):
273        """
274        Sets the closed property of the pattern.
275
276        Args:
277            value (bool): True to set the pattern as closed, False otherwise.
278        """
279        self.kernel.closed = value
280
281    @property
282    def composite(self) -> 'ndarray':
283        return self.transformation.composite
284
285    def __bool__(self):
286        return bool(self.kernel)
287
288    def get_all_vertices(self) -> 'ndarray':
289
290        return self.kernel.final_coords @ self.composite
291
292    @property
293    def b_box(self) -> BoundingBox:
294        """
295        Returns the bounding box of the pattern.
296
297        Returns:
298            BoundingBox: The bounding box of the pattern.
299        """
300        vertices = self.get_all_vertices()
301        verts=np.hsplit(vertices, self.count)
302        res = []
303        for x in verts:
304            pass # comeback here later!!!!!!
305
306        return bounding_box(vertices)
307
308    def get_vertices_list(self) -> list:
309        """
310        Returns the submatrices of the transformation.
311
312        Returns:
313            list: A list of submatrices.
314        """
315        return np.hsplit(self.get_all_vertices(), self.count)
316
317    def get_shapes(self) -> Batch:
318        """
319        Expands the pattern into a batch of shapes.
320
321        Returns:
322            Batch: A new Batch instance with the expanded shapes.
323        """
324        vertices_list = self.get_vertices_list()
325        res = Batch()
326        for vertices in vertices_list:
327            res.append(Shape(vertices))
328
329        return res
330
331    @property
332    def count(self):
333        """
334        Returns the number of occurrences of the pattern.
335
336        Returns:
337            int: The total number of forms in the pattern.
338        """
339
340        return prod([comp.reps+1 for comp in self.transformation.components])
341
342    def copy(self) -> 'Pattern':
343        """
344        Creates a copy of the Pattern instance.
345
346        Returns:
347            Pattern: A new Pattern instance with the same attributes.
348        """
349        kernel = None
350        if self.kernel is not None:
351            kernel = self.kernel.copy()
352
353        transformation = None
354        if self.transformation is not None:
355            transformation = self.transformation.copy()
356
357        pattern = Pattern(kernel, transformation)
358        for attrib in shape_style_map:
359            setattr(pattern, attrib, getattr(self, attrib))
360        return pattern
361
362    def translate(self, dx: float = 0, dy: float = 0, reps: int = 0) -> Self:
363        """
364        Translates the object by dx and dy.
365
366        Args:
367            dx (float): The translation distance along the x-axis.
368            dy (float): The translation distance along the y-axis.
369            reps (int, optional): The number of repetitions. Defaults to 0.
370
371        Returns:
372            Self: The transformed object.
373        """
374
375        component = Transform(translation_matrix(dx, dy), reps)
376        self.transformation.components.append(component)
377
378        return self
379
380    def rotate(self, angle: float, about: Point = (0, 0), reps: int = 0) -> Self:
381        """
382        Rotates the object by the given angle (in radians) about the given point.
383
384        Args:
385            angle (float): The rotation angle in radians.
386            about (Point, optional): The point to rotate about. Defaults to (0, 0).
387            reps (int, optional): The number of repetitions. Defaults to 0.
388
389        Returns:
390            Self: The rotated object.
391        """
392        component = Transform(rotation_matrix(angle, about), reps)
393        self.transformation.components.append(component)
394
395        return self
396
397    def mirror(self, about: Union[Line, Point], reps: int = 0) -> Self:
398        """
399        Mirrors the object about the given line or point.
400
401        Args:
402            about (Union[Line, Point]): The line or point to mirror about.
403            reps (int, optional): The number of repetitions. Defaults to 0.
404
405        Returns:
406            Self: The mirrored object.
407        """
408        component = Transform(mirror_matrix(about), reps)
409        self.transformation.components.append(component)
410
411        return self
412
413    def glide(self, glide_line: Line, glide_dist: float, reps: int = 0) -> Self:
414        """
415        Glides (first mirror then translate) the object along the given line
416        by the given glide_dist.
417
418        Args:
419            glide_line (Line): The line to glide along.
420            glide_dist (float): The distance to glide.
421            reps (int, optional): The number of repetitions. Defaults to 0.
422
423        Returns:
424            Self: The glided object.
425        """
426        component = Transform(glide_matrix(glide_line, glide_dist), reps)
427        self.transformation.components.append(component)
428
429        return self
430
431    def scale(
432        self,
433        scale_x: float,
434        scale_y: Union[float, None] = None,
435        about: Point = (0, 0),
436        reps: int = 0,
437    ) -> Self:
438        """
439        Scales the object by the given scale factors about the given point.
440
441        Args:
442            scale_x (float): The scale factor in the x direction.
443            scale_y (float, optional): The scale factor in the y direction. Defaults to None.
444            about (Point, optional): The point to scale about. Defaults to (0, 0).
445            reps (int, optional): The number of repetitions. Defaults to 0.
446
447        Returns:
448            Self: The scaled object.
449        """
450        if scale_y is None:
451            scale_y = scale_x
452        component = Transform(scale_in_place_matrix(scale_x, scale_y, about), reps)
453        self.transformation.components.append(component)
454
455        return self
456
457    def shear(self, theta_x: float, theta_y: float, reps: int = 0) -> Self:
458        """
459        Shears the object by the given angles.
460
461        Args:
462            theta_x (float): The shear angle in the x direction.
463            theta_y (float): The shear angle in the y direction.
464            reps (int, optional): The number of repetitions. Defaults to 0.
465
466        Returns:
467            Self: The sheared object.
468        """
469        component = Transform(shear_matrix(theta_x, theta_y), reps)
470        self.transformation.components.append(component)
471
472        return self
473
474    def transform(self, transform_matrix: 'ndarray', reps: int = 0) -> Self:
475        """
476        Transforms the pattern by the given transformation matrix.
477
478        Args:
479            transform_matrix (ndarray): The transformation matrix.
480            reps (int, optional): The number of repetitions. Defaults to 0.
481
482        Returns:
483            Self: The transformed pattern.
484        """
485        return self._update(transform_matrix, reps=reps)
486
487    def move_to(self, pos: Point, anchor: Anchor = Anchor.CENTER) -> Self:
488        """
489        Moves the object to the given position by using its center point.
490
491        Args:
492            pos (Point): The position to move to.
493            anchor (Anchor, optional): The anchor point. Defaults to Anchor.CENTER.
494
495        Returns:
496            Self: The moved object.
497        """
498        x, y = pos[:2]
499        anchor = get_enum_value(Anchor, anchor)
500        x1, y1 = getattr(self.b_box, anchor)
501        component = Transform(translation_matrix(x - x1, y - y1), reps=0)
502        self.transformation.components.append(component)
503
504        return self