simetri.graphics.batch

  1"""Batch objects are used for grouping other Shape and Batch objects.
  2"""
  3
  4from typing import Any, Iterator, List, Sequence
  5
  6from numpy import around, array
  7from typing_extensions import Self, Dict
  8import networkx as nx
  9
 10
 11from .all_enums import Types, batch_types, get_enum_value
 12from .common import common_properties, _set_Nones, Point, Line
 13from .core import Base
 14from .bbox import bounding_box
 15from ..canvas.style_map import batch_args
 16from ..helpers.validation import validate_args
 17from ..geometry.geometry import(
 18    fix_degen_points,
 19    get_polygons,
 20    all_close_points,
 21    mid_point,
 22    distance,
 23    connected_pairs,
 24    round_segment,
 25    round_point
 26)
 27from ..helpers.graph import is_cycle, is_open_walk, Graph
 28from ..settings.settings import defaults
 29
 30from .merge import _merge_shapes, _merge_collinears
 31
 32
 33class Batch(Base):
 34    """
 35    A Batch object is a collection of other objects (Batch, Shape,
 36    and Tag objects). It can be used to apply a transformation to
 37    all the objects in the Batch. It is used for creating 1D and 2D
 38    patterns of objects. all_vertices, all_elements, etc. means a flat
 39    list of the specified object gathered recursively from all the
 40    elements in the Batch.
 41    """
 42
 43    def __init__(
 44        self,
 45        elements: Sequence[Any] = None,
 46        modifiers: Sequence["Modifier"] = None,
 47        subtype: Types = Types.BATCH,
 48        **kwargs,
 49    ):
 50        """
 51        Initialize a Batch object.
 52
 53        Args:
 54            elements (Sequence[Any], optional): The elements to include in the batch.
 55            modifiers (Sequence[Modifier], optional): The modifiers to apply to the batch.
 56            subtype (Types, optional): The subtype of the batch.
 57            kwargs (dict): Additional keyword arguments.
 58        """
 59        validate_args(kwargs, batch_args)
 60        if elements and not isinstance(elements, (list, tuple)):
 61            self.elements = [elements]
 62        else:
 63            self.elements = elements if elements is not None else []
 64        self.type = Types.BATCH
 65        self.subtype = get_enum_value(Types, subtype)
 66        self.modifiers = modifiers
 67        self.blend_mode = None
 68        self.alpha = None
 69        self.line_alpha = None
 70        self.fill_alpha = None
 71        self.text_alpha = None
 72        self.clip = False  # if clip is True, the batch.mask is used as a clip path
 73        self.mask = None
 74        self.even_odd_rule = False
 75        self.blend_group = False
 76        self.transparency_group = False
 77        common_properties(self)
 78        for key, value in kwargs.items():
 79            setattr(self, key, value)
 80
 81    def set_attribs(self, attrib, value):
 82        """
 83        Sets the attribute to the given value for all elements in the batch if it is applicable.
 84
 85        Args:
 86            attrib (str): The attribute to set.
 87            value (Any): The value to set the attribute to.
 88        """
 89        for element in self.elements:
 90            if element.type == Types.BATCH:
 91                setattr(element, attrib, value)
 92            elif hasattr(element, attrib):
 93                setattr(element, attrib, value)
 94
 95    def set_batch_attr(self, attrib: str, value: Any) -> Self:
 96        """
 97        Sets the attribute to the given value for the batch itself.
 98        batch.attrib = value would set the attribute to the elements
 99        of the batch object but not the batch itself.
100
101        Args:
102            attrib (str): The attribute to set.
103            value (Any): The value to set the attribute to.
104
105        Returns:
106            Self: The batch object.
107        """
108        self.__dict__[attrib] = value
109
110    def __str__(self):
111        """
112        Return a string representation of the batch.
113
114        Returns:
115            str: The string representation of the batch.
116        """
117        if self.elements is None or len(self.elements) == 0:
118            res = "Batch()"
119        elif len(self.elements) in [1, 2]:
120            res = f"Batch({self.elements})"
121        else:
122            res = f"Batch({self.elements[0]}...{self.elements[-1]})"
123        return res
124
125    def __repr__(self):
126        """
127        Return a string representation of the batch.
128
129        Returns:
130            str: The string representation of the batch.
131        """
132        return self.__str__()
133
134    def __len__(self):
135        """
136        Return the number of elements in the batch.
137
138        Returns:
139            int: The number of elements in the batch.
140        """
141        return len(self.elements)
142
143    def __getitem__(self, subscript):
144        """
145        Get the element(s) at the given subscript.
146
147        Args:
148            subscript (int or slice): The subscript to get the element(s) from.
149
150        Returns:
151            Any: The element(s) at the given subscript.
152        """
153        if isinstance(subscript, slice):
154            res = self.elements[subscript.start : subscript.stop : subscript.step]
155        else:
156            res = self.elements[subscript]
157        return res
158
159    def __setitem__(self, subscript, value):
160        """
161        Set the element(s) at the given subscript.
162
163        Args:
164            subscript (int or slice): The subscript to set the element(s) at.
165            value (Any): The value to set the element(s) to.
166        """
167        elements = self.elements
168        if isinstance(subscript, slice):
169            elements[subscript.start : subscript.stop : subscript.step] = value
170        elif isinstance(subscript, int):
171            elements[subscript] = value
172        else:
173            raise TypeError("Invalid subscript type")
174
175    def __add__(self, other: "Batch") -> "Batch":
176        """
177        Add another batch to this batch.
178
179        Args:
180            other (Batch): The other batch to add.
181
182        Returns:
183            Batch: The combined batch.
184
185        Raises:
186            RuntimeError: If the other object is not a batch.
187        """
188        if other.type == Types.BATCH:
189            batch = self.copy()
190            for element in other.elements:
191                batch.append(element)
192            res = batch
193        else:
194            raise RuntimeError(
195                "Invalid object. Only Batch objects can be added together!"
196            )
197        return res
198
199    def __bool__(self):
200        """
201        Return whether the batch has any elements.
202
203        Returns:
204            bool: True if the batch has elements, False otherwise.
205        """
206        return len(self.elements) > 0
207
208    def __iter__(self):
209        """
210        Return an iterator over the elements in the batch.
211
212        Returns:
213            Iterator: An iterator over the elements in the batch.
214        """
215        return iter(self.elements)
216
217    def _duplicates(self, elements):
218        """
219        Check for duplicate elements in the batch.
220
221        Args:
222            elements (Sequence[Any]): The elements to check for duplicates.
223
224        Raises:
225            ValueError: If duplicate elements are found.
226
227        Returns:
228            bool: True if duplicates are found, False otherwise.
229        """
230        for element in elements:
231            ids = [x.id for x in self.elements]
232            if element.id in ids:
233                raise ValueError("Only unique elements are allowed!")
234
235        return len(set(elements)) != len(elements)
236
237    def proximity(self, dist_tol: float = None, n: int = 5) -> list[Point]:
238        """
239        Returns the n closest points in the batch.
240
241        Args:
242            dist_tol (float, optional): The distance tolerance for proximity.
243            n (int, optional): The number of closest points to return.
244
245        Returns:
246            list[Point]: The n closest points in the batch.
247        """
248        if dist_tol is None:
249            dist_tol = defaults["dist_tol"]
250        vertices = self.all_vertices
251        vertices = [(*v, i) for i, v in enumerate(vertices)]
252        _, pairs = all_close_points(vertices, dist_tol=dist_tol, with_dist=True)
253        return [pair for pair in pairs if pair[2] > 0][:n]
254
255    def append(self, element: Any) -> Self:
256        """
257        Appends the element to the batch.
258
259        Args:
260            element (Any): The element to append.
261
262        Returns:
263            Self: The batch object.
264        """
265        if element not in self.elements:
266            self.elements.append(element)
267        return self
268
269    def reverse(self) -> Self:
270        """
271        Reverses the order of the elements in the batch.
272
273        Returns:
274            Self: The batch object.
275        """
276        self.elements = self.elements[::-1]
277        return self
278
279    def insert(self, index, element: Any) -> Self:
280        """
281        Inserts the element at the given index.
282
283        Args:
284            index (int): The index to insert the element at.
285            element (Any): The element to insert.
286
287        Returns:
288            Self: The batch object.
289        """
290        if element not in self.elements:
291            self.elements.insert(index, element)
292
293        return self
294
295    def remove(self, element: Any) -> Self:
296        """
297        Removes the element from the batch.
298
299        Args:
300            element (Any): The element to remove.
301
302        Returns:
303            Self: The batch object.
304        """
305        if element in self.elements:
306            self.elements.remove(element)
307        return self
308
309    def pop(self, index: int) -> Any:
310        """
311        Removes the element at the given index and returns it.
312
313        Args:
314            index (int): The index to remove the element from.
315
316        Returns:
317            Any: The removed element.
318        """
319        return self.elements.pop(index)
320
321    def clear(self) -> Self:
322        """
323        Removes all elements from the batch.
324
325        Returns:
326            Self: The batch object.
327        """
328        self.elements = []
329        return self
330
331    def extend(self, elements: Sequence[Any]) -> Self:
332        """
333        Extends the batch with the given elements.
334
335        Args:
336            elements (Sequence[Any]): The elements to extend the batch with.
337
338        Returns:
339            Self: The batch object.
340        """
341        for element in elements:
342            if element not in self.elements:
343                self.elements.append(element)
344
345        return self
346
347    def iter_elements(self, element_type: Types = None) -> Iterator:
348        """Iterate over all elements in the batch, including the elements
349        in the nested batches.
350
351        Args:
352            element_type (Types, optional): The type of elements to iterate over. Defaults to None.
353
354        Returns:
355            Iterator: An iterator over the elements in the batch.
356        """
357        for elem in self.elements:
358            if elem.type == Types.BATCH:
359                yield from elem.iter_elements(element_type)
360            else:
361                if element_type is None:
362                    yield elem
363                elif elem.type == element_type:
364                    yield elem
365
366    @property
367    def all_elements(self) -> list[Any]:
368        """Return a list of all elements in the batch,
369        including the elements in the nested batches.
370
371        Returns:
372            list[Any]: A list of all elements in the batch.
373        """
374        elements = []
375        for elem in self.elements:
376            if elem.type == Types.BATCH:
377                elements.extend(elem.all_elements)
378            else:
379                elements.append(elem)
380        return elements
381
382    @property
383    def all_shapes(self) -> list["Shape"]:
384        """Return a list of all shapes in the batch.
385
386        Returns:
387            list[Shape]: A list of all shapes in the batch.
388        """
389        elements = self.all_elements
390        shapes = []
391        for element in elements:
392            if element.type == Types.SHAPE:
393                shapes.append(element)
394        return shapes
395
396    @property
397    def all_vertices(self) -> list[Point]:
398        """Return a list of all points in the batch in their
399        transformed positions.
400
401        Returns:
402            list[Point]: A list of all points in the batch in their transformed positions.
403        """
404        elements = self.all_elements
405        vertices = []
406        for element in elements:
407            if element.type == Types.SHAPE:
408                vertices.extend(element.vertices)
409            elif element.type == Types.BATCH:
410                vertices.extend(element.all_vertices)
411        return vertices
412
413    @property
414    def all_segments(self) -> list[Line]:
415        """Return a list of all segments in the batch.
416
417        Returns:
418            list[Line]: A list of all segments in the batch.
419        """
420        elements = self.all_elements
421        segments = []
422        for element in elements:
423            if element.type == Types.SHAPE:
424                segments.extend(element.vertex_pairs)
425        return segments
426
427
428    def _get_graph_nodes_and_edges(self, dist_tol: float = None, n_round=None):
429        """Get the graph nodes and edges for the batch.
430
431        Args:
432            dist_tol (float, optional): The distance tolerance for proximity. Defaults to None.
433            n_round (int, optional): The number of decimal places to round to. Defaults to None.
434
435        Returns:
436            tuple: A tuple containing the node coordinates and edges.
437        """
438        if n_round is None:
439            n_round = defaults["n_round"]
440        _set_Nones(self, ["dist_tol", "n_round"], [dist_tol, n_round])
441        vertices = self.all_vertices
442        shapes = self.all_shapes
443        d_ind_coords = {}
444        point_id = []
445        rounded_vertices = []
446        for i, vert in enumerate(vertices):
447            coords = tuple(around(vert, n_round))
448            rounded_vertices.append(coords)
449            d_ind_coords[i] = coords
450            point_id.append([vert[0], vert[1], i])
451
452        _, pairs = all_close_points(point_id, dist_tol=dist_tol, with_dist=True)
453
454        for pair in pairs:
455            id1, id2, _ = pair
456            average = tuple(mid_point(vertices[id1], vertices[id2]))
457            d_ind_coords[id1] = average
458            d_ind_coords[id2] = average
459            rounded_vertices[id1] = average
460            rounded_vertices[id2] = average
461
462        d_coords_node_id = {}
463        d_node_id__rounded_coords = {}
464
465        s_rounded_vertices = set(rounded_vertices)
466        for i, vertex in enumerate(s_rounded_vertices):
467            d_coords_node_id[vertex] = i
468            d_node_id__rounded_coords[i] = vertex
469
470        edges = []
471        ind = 0
472        for shape in shapes:
473            node_ids = []
474            s_vertices = shape.vertices[:]
475            for vertex in s_vertices:
476                node_ids.append(d_coords_node_id[rounded_vertices[ind]])
477                ind += 1
478            edges.extend(connected_pairs(node_ids))
479            if shape.closed:
480                edges.append((node_ids[-1], node_ids[0]))
481
482        return d_node_id__rounded_coords, edges
483
484    def as_graph(
485        self,
486        directed: bool = False,
487        weighted: bool = False,
488        dist_tol: float = None,
489        atol=None,
490        n_round: int = None,
491    ) -> Graph:
492        """Return the batch as a Graph object.
493        Graph.nx is the networkx graph.
494
495        Args:
496            directed (bool, optional): Whether the graph is directed. Defaults to False.
497            weighted (bool, optional): Whether the graph is weighted. Defaults to False.
498            dist_tol (float, optional): The distance tolerance for proximity. Defaults to None.
499            atol (optional): The absolute tolerance. Defaults to None.
500            n_round (int, optional): The number of decimal places to round to. Defaults to None.
501
502        Returns:
503            Graph: The batch as a Graph object.
504        """
505        _set_Nones(self, ["dist_tol", "atol", "n_round"], [dist_tol, atol, n_round])
506        d_node_id_coords, edges = self._get_graph_nodes_and_edges(dist_tol, n_round)
507        if directed:
508            nx_graph = nx.DiGraph()
509            graph_type = Types.DIRECTED
510        else:
511            nx_graph = nx.Graph()
512            graph_type = Types.UNDIRECTED
513
514        for id_, coords in d_node_id_coords.items():
515            nx_graph.add_node(id_, pos=coords)
516
517        if weighted:
518            for edge in edges:
519                p1 = d_node_id_coords[edge[0]]
520                p2 = d_node_id_coords[edge[1]]
521                nx_graph.add_edge(edge[0], edge[1], weight=distance(p1, p2))
522            subtype = Types.WEIGHTED
523        else:
524            nx_graph.update(edges)
525            subtype = Types.NONE
526
527        graph = Graph(type=graph_type, subtype=subtype, nx_graph=nx_graph)
528        return graph
529
530    def graph_summary(self, dist_tol: float = None, n_round: int = None) -> str:
531        """Returns a representation of the Batch object as a graph.
532
533        Args:
534            dist_tol (float, optional): The distance tolerance for proximity. Defaults to None.
535            n_round (int, optional): The number of decimal places to round to. Defaults to None.
536
537        Returns:
538            str: A representation of the Batch object as a graph.
539        """
540        if dist_tol is None:
541            dist_tol = defaults["dist_tol"]
542        if n_round is None:
543            n_round = defaults["n_round"]
544        all_shapes = self.all_shapes
545        all_vertices = self.all_vertices
546        lines = []
547        lines.append("Batch summary:")
548        lines.append(f"# shapes: {len(all_shapes)}")
549        lines.append(f"# vertices: {len(all_vertices)}")
550        for shape in self.all_shapes:
551            if shape.subtype:
552                s = (
553                    f"# vertices in shape(id: {shape.id}, subtype: "
554                    f"{shape.subtype}): {len(shape.vertices)}"
555                )
556            else:
557                s = f"# vertices in shape(id: {shape.id}): " f"{len(shape.vertices)}"
558            lines.append(s)
559        graph = self.as_graph(dist_tol=dist_tol, n_round=n_round).nx_graph
560
561        for island in nx.connected_components(graph):
562            lines.append(f"Island: {island}")
563            if is_cycle(graph, island):
564                lines.append(f"Cycle: {len(island)} nodes")
565            elif is_open_walk(graph, island):
566                lines.append(f"Open Walk: {len(island)} nodes")
567            else:
568                degens = [node for node in island if graph.degree(node) > 2]
569                degrees = f"{[(node, graph.degree(node)) for node in degens]}"
570                lines.append(f"Degenerate: {len(island)} nodes")
571                lines.append(f"(Node, Degree): {degrees}")
572            lines.append("-" * 40)
573
574        return "\n".join(lines)
575
576    def _merge_collinears(self, edges, n_round=2):
577        """Merge collinear edges in the batch.
578
579        Args:
580            d_node_id_coords (dict): The node coordinates.
581            edges (list): The edges to merge.
582            tol (float, optional): The tolerance for merging. Defaults to None.
583            rtol (float, optional): The relative tolerance. Defaults to None.
584            atol (float, optional): The absolute tolerance. Defaults to None.
585
586        Returns:
587            list: The merged edges.
588        """
589        return _merge_collinears(self, edges, n_round=n_round)
590
591    def merge_shapes(
592        self, dist_tol: float = None, n_round: int = None) -> Self:
593        """Merges the shapes in the batch if they are connected.
594        Returns a new batch with the merged shapes as well as the shapes
595        as well as the shapes that could not be merged.
596
597        Args:
598            tol (float, optional): The tolerance for merging shapes. Defaults to None.
599            rtol (float, optional): The relative tolerance. Defaults to None.
600            atol (float, optional): The absolute tolerance. Defaults to None.
601
602        Returns:
603            Self: The batch object with merged shapes.
604        """
605        return _merge_shapes(self, dist_tol=dist_tol, n_round=n_round)
606
607    def _get_edges_and_segments(self, dist_tol: float = None, n_round: int = None):
608        """Get the edges and segments for the batch.
609
610        Args:
611            dist_tol (float, optional): The distance tolerance for proximity. Defaults to None.
612            n_round (int, optional): The number of decimal places to round to. Defaults to None.
613
614        Returns:
615            tuple: A tuple containing the edges and segments.
616        """
617        if dist_tol is None:
618            dist_tol = defaults["dist_tol"]
619        if n_round is None:
620            n_round = defaults["n_round"]
621        d_coord_node = self.d_coord_node
622        segments = self.all_segments
623        segments = [round_segment(segment, n_round) for segment in segments]
624        edges = []
625        for seg in segments:
626            p1, p2 = seg
627            id1 = d_coord_node[p1]
628            id2 = d_coord_node[p2]
629            edges.append((id1, id2))
630
631        return edges, segments
632
633    def _set_node_dictionaries(self, coords: List[Point], n_round: int=2) -> List[Dict]:
634        '''Set dictionaries for nodes and coordinates.
635        d_node_coord: Dictionary of node id to coordinates.
636        d_coord_node: Dictionary of coordinates to node id.
637
638        Args:
639            nodes (List[Point]): List of vertices.
640            n_round (int, optional): Number of rounding digits. Defaults to 2.
641        '''
642
643        coords = [tuple(round_point(coord, n_round)) for coord in coords]
644        coords = list(set(coords))   # remove duplicates
645        coords.sort()    # sort by x coordinates
646        coords.sort(key=lambda x: x[1])  # sort by y coordinates
647
648        d_node_coord = {}
649        d_coord_node = {}
650
651        for i, coord in enumerate(coords):
652            d_node_coord[i] = coord
653            d_coord_node[coord] = i
654
655        self.d_node_coord = d_node_coord
656        self.d_coord_node = d_coord_node
657
658    def all_polygons(self, dist_tol: float = None) -> list:
659        """Return a list of all polygons in the batch in their
660        transformed positions.
661
662        Args:
663            dist_tol (float, optional): The distance tolerance for proximity. Defaults to None.
664
665        Returns:
666            list: A list of all polygons in the batch.
667        """
668        if dist_tol is None:
669            dist_tol = defaults["dist_tol"]
670        exclude = []
671        include = []
672        for shape in self.all_shapes:
673            if len(shape.primary_points) > 2 and shape.closed:
674                vertices = shape.vertices
675                exclude.append(vertices)
676            else:
677                include.append(shape)
678        polylines = []
679        for element in include:
680            points = element.vertices
681            points = fix_degen_points(points, dist_tol=dist_tol, closed=element.closed)
682            polylines.append(points)
683        fixed_polylines = []
684        if polylines:
685            for polyline in polylines:
686                fixed_polylines.append(
687                    fix_degen_points(polyline, dist_tol=dist_tol, closed=True)
688                )
689            polygons = get_polygons(fixed_polylines, dist_tol=dist_tol)
690            res = polygons + exclude
691        else:
692            res = exclude
693        return res
694
695    def copy(self) -> "Batch":
696        """Returns a copy of the batch.
697
698        Returns:
699            Batch: A copy of the batch.
700        """
701        b = Batch(modifiers=self.modifiers)
702        if self.elements:
703            b.elements = [elem.copy() for elem in self.elements]
704        else:
705            b.elements = []
706        custom_attribs = custom_batch_attributes(self)
707        for attrib in custom_attribs:
708            setattr(b, attrib, getattr(self, attrib))
709        return b
710
711    @property
712    def b_box(self):
713        """Returns the bounding box of the batch.
714
715        Returns:
716            BoundingBox: The bounding box of the batch.
717        """
718        xy_list = []
719        for elem in self.elements:
720            if hasattr(elem, "b_box"):
721                xy_list.extend(elem.b_box.corners)  # To do: we should eliminate this. Just add all points.
722        # To do: memoize the bounding box
723        return bounding_box(array(xy_list))
724
725    def _modify(self, modifier):
726        """Apply a modifier to the batch.
727
728        Args:
729            modifier (Modifier): The modifier to apply.
730        """
731        modifier.apply()
732
733    def _update(self, xform_matrix, reps: int = 0):
734        """Updates the batch with the given transformation matrix.
735        If reps is 0, the transformation is applied to all elements.
736        If reps is greater than 0, the transformation creates
737        new elements with the transformed xform_matrix.
738
739        Args:
740            xform_matrix (ndarray): The transformation matrix.
741            reps (int, optional): The number of repetitions. Defaults to 0.
742        """
743        if reps == 0:
744            for element in self.elements:
745                element._update(xform_matrix, reps=0)
746                if self.modifiers:
747                    for modifier in self.modifiers:
748                        modifier.apply(element)
749        else:
750            elements = self.elements[:]
751            new = []
752            for _ in range(reps):
753                for element in elements:
754                    new_element = element.copy()
755                    new_element._update(xform_matrix)
756                    self.elements.append(new_element)
757                    new.append(new_element)
758                    if self.modifiers:
759                        for modifier in self.modifiers:
760                            modifier.apply(new_element)
761                elements = new[:]
762                new = []
763        return self
764
765
766def custom_batch_attributes(item: Batch) -> List[str]:
767    """
768    Return a list of custom attributes of a Shape or
769    Batch instance.
770
771    Args:
772        item (Batch): The batch object.
773
774    Returns:
775        List[str]: A list of custom attributes.
776    """
777    from .shape import Shape
778
779    if isinstance(item, Batch):
780        dummy_shape = Shape([(0, 0), (1, 0)])
781        dummy = Batch([dummy_shape])
782    else:
783        raise TypeError("Invalid item type")
784    native_attribs = set(dir(dummy))
785    custom_attribs = set(dir(item)) - native_attribs
786
787    return list(custom_attribs)