simetri.wallpaper.wallpaper

  1"""Simetri graphics library's wallpaper patterns.
  2"""
  3
  4# Only six of the 17 wallpaper groups are tested yet.
  5
  6from math import sqrt, pi, cos
  7
  8from typing import Union
  9
 10from ..geometry.geometry import mid_point, line_through_point_and_angle
 11from ..graphics.common import VecType, Point, Line
 12from ..helpers.illustration import Tag
 13from ..graphics.batch import Batch
 14from ..graphics.shape import Shape
 15
 16
 17cos60 = cos(pi / 3)
 18cos30 = cos(pi / 6)
 19
 20
 21def cover_hex(
 22    item: Union[Batch, Shape, Tag],
 23    size: float,
 24    gap: float = 0,
 25    reps1: int = 2,
 26    reps2: int = 2,
 27    flat: bool = True,
 28) -> Batch:
 29    """
 30    Covers an area with a hexagonal pattern.
 31
 32    Args:
 33        item (Union[Batch, Shape, Tag]): The item to be repeated.
 34        size (float): The size of the hexagons.
 35        gap (float, optional): The gap between hexagons. Defaults to 0.
 36        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 2.
 37        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 2.
 38        flat (bool, optional): If True, hexagons are flat-topped. Defaults to True.
 39
 40    Returns:
 41        Batch: The resulting pattern as a Batch object.
 42    """
 43    gap_x = 2 * gap * cos60
 44    gap_y = gap * cos30
 45    if (flat):
 46        w = 2 * size
 47        h = sqrt(3) * size
 48        dx = 3 * size + (gap_x * 2)
 49        dy = h + (gap_y * 2)
 50        item.translate((3 * size / 2) + gap_x, (h / 2) + gap_y, reps=1)
 51    else:
 52        w = sqrt(3) * size
 53        h = 2 * size
 54        dx = w + (gap_x * 2)
 55        dy = (2 * size) + (h / 2) + (gap_y * 2)
 56        item.translate((w / 2) + gap_x, (3 * h / 4) + gap_y, reps=1)
 57
 58    item.translate(dx, 0, reps=reps1)
 59    item.translate(0, dy, reps=reps2)
 60
 61    return item
 62
 63
 64def cover_rhombic(
 65    item: Union[Batch, Shape, Tag], size: float, reps1: int = 2, reps2: int = 2
 66) -> Batch:
 67    """
 68    Covers an area with a rhombic pattern.
 69
 70    Args:
 71        item (Union[Batch, Shape, Tag]): The item to be repeated.
 72        size (float): The size of the rhombuses.
 73        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 2.
 74        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 2.
 75
 76    Returns:
 77        Batch: The resulting pattern as a Batch object.
 78    """
 79    sqrt2 = sqrt(2)
 80    diag = (sqrt2 / 2) * size
 81    item.translate(diag, diag, reps=1)
 82    dx = dy = diag * 2
 83    item.translate(dx, 0, reps=reps1)
 84    item.translate(0, dy, reps=reps2)
 85
 86    return item
 87
 88
 89def hex_grid_pointy(x: float, y: float, size: float, n_rows: int, n_cols: int) -> Batch:
 90    """
 91    Creates a hexagonal grid with pointy tops.
 92
 93    Args:
 94        x (float): The x-coordinate of the starting point.
 95        y (float): The y-coordinate of the starting point.
 96        size (float): The size of the hexagons.
 97        n_rows (int): Number of rows in the grid.
 98        n_cols (int): Number of columns in the grid.
 99
100    Returns:
101        Batch: The resulting grid as a Batch of Shapes.
102    """
103    height = sqrt(3) * size
104    width = 2 * size
105    edge_length = 2 * size * cos(pi / 6)
106    # create the first row by translating a single hexagon in the x direction
107    row = Batch(Shape([(x, y)])).translate(size, 0, reps=n_cols - 1)
108    # create the second row by translating the first row
109    two_rows = row.translate(width, height + edge_length, reps=1)
110    # create the grid by translating the first and second row in the y direction
111    grid = two_rows.translate(0, 2 * size + edge_length, reps=n_rows / 2 - 1)
112
113    return grid
114
115
116def cover_hex_pointy(
117    item: Union[Shape, Batch, Tag],
118    size: float,
119    gap: float = 0,
120    reps1: int = 2,
121    reps2: int = 2,
122) -> Batch:
123    """
124    Covers an area with a hexagonal pattern with pointy tops.
125
126    Args:
127        item (Union[Shape, Batch, Tag]): The item to be repeated.
128        size (float): The size of the hexagons.
129        gap (float, optional): The gap between hexagons. Defaults to 0.
130        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 2.
131        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 2.
132
133    Returns:
134        Batch: The resulting pattern as a Batch object.
135    """
136    gap_x = 2 * gap * cos60
137    gap_y = gap * cos30
138    w = sqrt(3) * size
139    h = 2 * size
140    dx = w + (gap_x * 2)
141    dy = (2 * size) + (h / 2) + (gap_y * 2)
142    item.translate((w / 2) + gap_x, (3 * h / 4) + gap_y, reps=1)
143    item.translate(dx, 0, reps=reps1)
144    item.translate(0, dy, reps=reps2)
145
146    return item
147
148
149def cover_hex_flat(
150    item: Union[Batch, Shape, Tag],
151    size: float,
152    gap: float = 0,
153    reps1: int = 2,
154    reps2: int = 2,
155) -> Batch:
156    """
157    Covers an area with a hexagonal pattern with flat tops.
158
159    Args:
160        item (Union[Batch, Shape, Tag]): The item to be repeated.
161        size (float): The size of the hexagons.
162        gap (float, optional): The gap between hexagons. Defaults to 0.
163        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 2.
164        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 2.
165
166    Returns:
167        Batch: The resulting pattern as a Batch object.
168    """
169    gap_x = 2 * gap * cos60
170    gap_y = gap * cos30
171    h = sqrt(3) * size
172    dx = 3 * size + (gap_x * 2)
173    dy = h + (gap_y * 2)
174    item.translate((3 * size / 2) + gap_x, (h / 2) + gap_y, reps=1)
175    item.translate(dx, 0, reps=reps1)
176    item.translate(0, dy, reps=reps2)
177
178    return item
179
180
181# Wallpaper groups
182
183# generator is the primary cell
184# tile is the basic unit cell
185# mirrors
186# glide-mirror (m1, m2), glide-dist (dist1, dist2) if more than one
187# rotocenters
188# n rotations (n1, n2, ...) corresponding to each rotocenter
189# translations (vec1, n1, vec2, n2) this is the lattice
190
191
192def wallpaper_p1(
193    generator: Union[Batch, Shape, Tag],
194    vector1: VecType,
195    vector2: VecType,
196    reps1: int = 4,
197    reps2: int = 4,
198) -> Batch:
199    """
200    Translation symmetry.
201    IUC: p1
202    Conway: o
203    Oblique lattice
204    Point group: C1
205
206    Args:
207        generator (Union[Batch, Shape, Tag]): The repeating motif.
208        vector1 (VecType): The translation vector in the x direction.
209        vector2 (VecType): The translation vector in the y direction.
210        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
211        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
212
213    Returns:
214        Batch: The resulting wallpaper pattern as a Batch object.
215    """
216    dx1, dy1 = vector1
217    wallpaper = generator.translate(dx1, dy1, reps1)
218    dx2, dy2 = vector2
219    wallpaper.translate(dx2, dy2, reps2)
220
221    return wallpaper
222
223
224def wallpaper_p2(
225    generator: Union[Shape, Batch, Tag],
226    vector1: VecType,
227    vector2: VecType,
228    reps1: int = 4,
229    reps2: int = 4,
230) -> Batch:
231    """
232    Half-turn rotation symmetry.
233    IUC: p2 (p211)
234    Conway: 2222
235    Oblique lattice
236    Point group: C2
237
238    Args:
239        generator (Union[Shape, Batch, Tag]): The repeating motif.
240        vector1 (VecType): The translation vector in the x direction.
241        vector2 (VecType): The translation vector in the y direction.
242        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
243        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
244
245    Returns:
246        Batch: The resulting wallpaper pattern as a Batch object.
247    """
248    rotocenter = mid_point(vector1, vector2)
249    wallpaper = generator.rotate(pi, rotocenter, reps=1)
250    dx1, dy1 = vector1
251    wallpaper.translate(dx1, dy1, reps=reps1)
252    dx2, dy2 = vector2
253    wallpaper.translate(dx2, dy2, reps=reps2)
254
255    return wallpaper
256
257
258def wallpaper_p2_rect_lattice(
259    generator: Union[Shape, Batch, Tag],
260    rotocenter: Point,
261    vector1: VecType,
262    vector2: VecType,
263    reps1: int = 4,
264    reps2: int = 4,
265) -> Batch:
266    # """
267    # Half-turn rotation symmetry.
268    # IUC: p2 (p211)
269    # Conway: 2222
270    # Oblique lattice
271    # Point group: C2
272
273    # Point argument can be an Anchor object or a tuple, or two points can be given
274    # as a sequence.
275
276    # Example:
277    # import simetri.graphics as sg
278    # import simetri.wallpaper as wp
279
280    # directory = 'dir_path'
281    # canvas = sg.Canvas()
282
283    # F = sg.letter_F()
284    # vec1 = (2 * F.width + 10, 0)
285    # vec2 = (0, F.height + 10)
286
287    # pattern = wp.wallpaper_p2(F, vec1, vec2, reps1=2, reps2=2)
288    # file_path = os.path.join(directory, 'wallpaper_test_p2.pdf')
289    # canvas.draw(pattern, file_path=file_path)
290
291    # """
292
293    rotocenter = mid_point(vector1, vector2)
294    wallpaper = generator.rotate(pi, rotocenter, reps=1)
295    dx1, dy1 = vector1
296    wallpaper.translate(dx1, dy1, reps=reps1)
297    dx2, dy2 = vector2
298    wallpaper.translate(dx2, dy2, reps=reps2)
299
300    return wallpaper
301
302
303def wallpaper_p3(
304    generator: Union[Shape, Batch, Tag],
305    rotocenter: Point,
306    distance: float,
307    reps1: int = 4,
308    reps2: int = 4,
309    flat_hex: bool = False,
310) -> Batch:
311    """
312    Three rotations.
313    IUC: p3
314    Conway: 333
315    Hexagonal lattice.
316    Point group: C3
317
318    Args:
319        generator (Union[Shape, Batch, Tag]): The repeating motif.
320        rotocenter (Point): The center of rotation.
321        distance (float): The distance between the centers of the hexagons.
322        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
323        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
324        flat_hex (bool, optional): If True, hexagons are flat-topped. Defaults to False.
325
326    Returns:
327        Batch: The resulting wallpaper pattern as a Batch object.
328    """
329    wallpaper = generator.rotate(2 * pi / 3, rotocenter, reps=2)
330    if flat_hex:
331        cover_hex_flat(wallpaper, distance, reps1=reps1, reps2=reps2)
332    else:
333        cover_hex_pointy(wallpaper, distance, reps1=reps1, reps2=reps2)
334
335    return wallpaper
336
337
338def wallpaper_p4(
339    generator: Union[Batch, Shape, Tag],
340    rotocenter: Point,
341    distance: float,
342    reps1: int = 4,
343    reps2: int = 4,
344) -> Batch:
345    """
346    Pinwheel symmetry.
347    IUC: p4
348    Conway: 442
349    Square lattice
350    Point group: C4
351
352    Args:
353        generator (Union[Batch, Shape, Tag]): The repeating motif.
354        rotocenter (Point): The center of rotation.
355        distance (float): The distance between the centers of the squares.
356        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
357        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
358
359    Returns:
360        Batch: The resulting wallpaper pattern as a Batch object.
361    """
362    wallpaper = generator.rotate(pi / 2, rotocenter, reps=3)
363    wallpaper.translate(distance, 0, reps1)
364    wallpaper.translate(0, distance, reps2)
365
366    return wallpaper
367
368
369def wallpaper_p6(
370    generator: Union[Batch, Shape, Tag],
371    rotocenter: Point,
372    hex_size: float,
373    reps1: int = 4,
374    reps2: int = 4,
375    flat_hex=False,
376) -> Batch:
377    """
378    Six rotations.
379    IUC: p6
380    Conway : 632
381    Hexagonal lattice
382    Point group: C6
383
384    Args:
385        generator (Union[Batch, Shape, Tag]): The repeating motif.
386        rotocenter (Point): The center of rotation.
387        hex_size (float): The size of the hexagons.
388        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
389        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
390        flat_hex (bool, optional): If True, hexagons are flat-topped. Defaults to False.
391
392    Returns:
393        Batch: The resulting pattern as a Batch object.
394    """
395    wallpaper = generator.rotate(pi / 3, rotocenter, reps=5)
396    if flat_hex:
397        cover_hex_flat(wallpaper, hex_size, reps1=reps1, reps2=reps2)
398    else:
399        cover_hex_pointy(wallpaper, hex_size, reps1=reps1, reps2=reps2)
400
401    return wallpaper
402
403
404def wallpaper_pm(
405    generator: Union[Batch, Shape, Tag],
406    mirror_line: Line,
407    dx: float,
408    dy: float,
409    reps1: int = 4,
410    reps2: int = 4,
411) -> Batch:
412    """
413    Mirror symmetry.
414    Mirror could be horizontal or vertical.
415    IUC: pm(p1m1)
416    Conway : **
417    Rectangular lattice
418    Point group: D1
419
420    Args:
421        generator (Union[Batch, Shape, Tag]): The repeating motif.
422        mirror_line (Line): The line of symmetry.
423        dx (float): Translation distance in the x direction.
424        dy (float): Translation distance in the y direction.
425        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
426        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
427
428    Returns:
429        Batch: The resulting pattern as a Batch object.
430    """
431    wallpaper = generator.mirror(mirror_line, reps=1)
432    wallpaper.translate(dx, 0, reps=reps1)
433    wallpaper.translate(0, dy, reps=reps2)
434
435    return wallpaper
436
437
438def wallpaper_pg(
439    generator: Union[Batch, Shape, Tag],
440    mirror_line: Line,
441    distance: float,
442    dx: float,
443    dy: float,
444    reps1: int = 4,
445    reps2: int = 4,
446) -> Batch:
447    """
448    Glide symmetry.
449    IUC: pg(p1g1)
450    Conway : xx
451    Rectangular lattice
452    Point group: D1
453
454    Args:
455        generator (Union[Batch, Shape, Tag]): The repeating motif.
456        mirror_line (Line): The line of symmetry.
457        distance (float): The distance for the glide reflection.
458        dx (float): Translation distance in the x direction.
459        dy (float): Translation distance in the y direction.
460        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
461        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
462
463    Returns:
464        Batch: The resulting pattern as a Batch object.
465    """
466    wallpaper = generator.glide(mirror_line, distance, reps=1)
467    wallpaper.translate(dx, 0, reps=reps1)
468    wallpaper.translate(0, dy, reps=reps2)
469
470    return wallpaper
471
472
473def wallpaper_cm(
474    generator: Union[Batch, Shape, Tag],
475    mirror_point: Point,
476    rhomb_size: float,
477    reps1: int = 4,
478    reps2: int = 4,
479    horizontal: bool = True,
480) -> Batch:
481    """
482    Spinning-sidle symmetry.
483    IUC: cm(c1m1)
484    Conway : *x
485    Rhombic lattice
486    Point group: D1
487
488    Args:
489        generator (Union[Batch, Shape, Tag]): The repeating motif.
490        mirror_point (Point): The point of symmetry.
491        rhomb_size (float): The size of the rhombuses.
492        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
493        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
494        horizontal (bool, optional): If True, the mirror line is horizontal. Defaults to True.
495
496    Returns:
497        Batch: The resulting pattern as a Batch object.
498    """
499    x1, y1 = mirror_point
500    if horizontal:
501        x2, y2 = x1 + 1, y1
502    else:
503        x2, y2 = x1, y1 + 1
504    wallpaper = generator.mirror(((x1, y1), (x2, y2)), reps=1)
505    cover_rhombic(
506        wallpaper,
507        rhomb_size,
508        reps1=reps1,
509        reps2=reps2,
510    )
511
512    return wallpaper
513
514
515def wallpaper_pmm(
516    generator: Union[Batch, Shape, Tag],
517    mirror_cross: Point,
518    dx: float,
519    dy: float,
520    reps1=4,
521    reps2=4,
522) -> Batch:
523    """
524    Double mirror symmetry.
525    IUC: pmm(p2mm)
526    Conway : *2222
527    Rectangular lattice
528    Point group: D2
529
530    Args:
531        generator (Union[Batch, Shape, Tag]): The repeating motif.
532        mirror_cross (Point): The point where the mirror lines cross.
533        dx (float): Translation distance in the x direction.
534        dy (float): Translation distance in the y direction.
535        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
536        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
537
538    Returns:
539        Batch: The resulting pattern as a Batch object.
540    """
541    x, y = mirror_cross[:2]
542    mirror_line1 = ((x, y), (x + 1, y))
543    mirror_line2 = ((x, y), (x, y + 1))
544    wallpaper = generator.mirror(mirror_line1, reps=1)
545    wallpaper.mirror(mirror_line2, reps=1)
546    wallpaper.translate(dx, 0, reps=reps1)
547    wallpaper.translate(0, dy, reps=reps2)
548
549    return wallpaper
550
551
552def wallpaper_pmg(
553    generator: Union[Batch, Shape, Tag],
554    center_point: Point,
555    dx: float,
556    dy: float,
557    reps1=4,
558    reps2=4,
559    horizontal=True,
560) -> Batch:
561    """
562    Glided staggered symmetry.
563    IUC: pmg(p2mg)
564    Conway : 22*
565    Rectangular lattice
566    Point group: D2
567
568    Args:
569        generator (Union[Batch, Shape, Tag]): The repeating motif.
570        center_point (Point): The center point for the symmetry.
571        dx (float): Translation distance in the x direction.
572        dy (float): Translation distance in the y direction.
573        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
574        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
575        horizontal (bool, optional): If True, the mirror line is horizontal. Defaults to True.
576
577    Returns:
578        Batch: The resulting pattern as a Batch object.
579    """
580    x, y = center_point[:2]
581    if horizontal:
582        rotocenter = mid_point((x, y), (x, (y + dy) / 2))
583        mirror_line = ((x, y), (x + 1, y))
584    else:
585        rotocenter = mid_point((x, y), (-(x + dx) / 2, y))
586        mirror_line = ((x, y), (x, y + 1))
587    wallpaper = generator.rotate(pi, rotocenter, reps=1)
588    wallpaper.mirror(mirror_line, reps=1)
589    wallpaper.translate(dx, 0, reps=reps1)
590    wallpaper.translate(0, dy, reps=reps2)
591
592    return wallpaper
593
594
595def wallpaper_pgg(
596    generator: Union[Batch, Shape, Tag],
597    rotocenter: Point,
598    dx: float,
599    dy: float,
600    reps1: int = 4,
601    reps2: int = 4,
602    horizontal=True,
603) -> Batch:
604    """
605    Double glide symmetry.
606    IUC: pgg(p2gg)
607    Conway : 22x
608    Rectangular lattice
609    Point group: D2
610
611    Args:
612        generator (Union[Batch, Shape, Tag]): The repeating motif.
613        rotocenter (Point): The center of rotation.
614        dx (float): Translation distance in the x direction.
615        dy (float): Translation distance in the y direction.
616        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
617        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
618        horizontal (bool, optional): If True, the glide reflection is horizontal. Defaults to True.
619
620    Returns:
621        Batch: The resulting pattern as a Batch object.
622    """
623    if horizontal:
624        dist = rotocenter[0] - generator.center[0]
625        wallpaper = generator.glide(generator.horiz_centerline, 2 * dist, reps=1)
626        wallpaper.rotate(pi, rotocenter, reps=1)
627    else:
628        dist = rotocenter[1] - generator.center[1]
629        wallpaper = generator.glide(generator.vert_centerline, 2 * dist, reps=1)
630        wallpaper.rotate(pi, rotocenter, reps=1)
631    wallpaper.translate(dx, 0, reps1)
632    wallpaper.translate(0, dy, reps2)
633
634    return wallpaper
635
636
637def wallpaper_cmm(
638    generator: Union[Batch, Shape, Tag],
639    mirror_cross: Point,
640    rhomb_size: float,
641    reps1: int = 4,
642    reps2: int = 4,
643) -> Batch:
644    """
645    Staggered double mirror symmetry.
646    IUC: cmm(c2mm)
647    Conway : 2*22
648    Rhombic lattice
649    Point group: D2
650
651    Args:
652        generator (Union[Batch, Shape, Tag]): The repeating motif.
653        mirror_cross (Point): The point where the mirror lines cross.
654        rhomb_size (float): The size of the rhombuses.
655        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
656        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
657
658    Returns:
659        Batch: The resulting pattern as a Batch object.
660    """
661    x, y = mirror_cross[:2]
662    mirror_line1 = ((x, y), (x + 1, y))
663    mirror_line2 = ((x, y), (x, y + 1))
664    wallpaper = generator.mirror(mirror_line1, reps=1)
665    wallpaper.mirror(mirror_line2, reps=1)
666    cover_rhombic(wallpaper, rhomb_size, reps1=reps1, reps2=reps2)
667
668    return wallpaper
669
670
671def wallpaper_p4m(
672    generator: Union[Batch, Shape, Tag],
673    mirror_cross: Point,
674    side_length: float,
675    reps1: int = 4,
676    reps2: int = 4,
677) -> Batch:
678    """
679    Block symmetry.
680    IUC: p4m(p4mm)
681    Conway : *442
682    Square lattice
683    Point group: D4
684
685    Args:
686        generator (Union[Batch, Shape, Tag]): The repeating motif.
687        mirror_cross (Point): The point where the mirror lines cross.
688        side_length (float): The side length of the squares.
689        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
690        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
691
692    Returns:
693        Batch: The resulting pattern as a Batch object.
694    """
695    x, y = mirror_cross[:2]
696    mirror_line = ((x, y), (x, y + 1))
697    rotocenter = x, y
698    wallpaper = generator.mirror(mirror_line, reps=1)
699    wallpaper.rotate(pi / 2, rotocenter, reps=3)
700    wallpaper.translate(side_length, 0, reps=reps1)
701    wallpaper.translate(0, side_length, reps=reps2)
702
703    return wallpaper
704
705
706def wallpaper_p4g(
707    generator: Union[Batch, Shape, Tag], dist: float, reps1: int = 4, reps2: int = 4
708) -> Batch:
709    """
710    Mirrored pinwheel symmetry.
711    IUC: p4g(p4gm)
712    Conway : 4*2
713    Square lattice
714    Point group: D4
715
716    Args:
717        generator (Union[Batch, Shape, Tag]): The repeating motif.
718        dist (float): The distance between the centers of the squares.
719        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
720        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
721
722    Returns:
723        Batch: The resulting pattern as a Batch object.
724    """
725    # rotocenter should be (0, 0) and mirror_cross should be (d/4,d/4 )
726    # translations are (d, d)
727
728    wallpaper = generator.rotate(pi / 2, (0, 0), reps=3)
729    x, y = (dist / 4, dist / 4)
730    wallpaper.mirror(((x, y), (x + 1, y)), reps=1)
731    wallpaper.mirror(((x, y), (x, y + 1)), reps=1)
732    wallpaper.translate(dist, 0, reps=reps1)
733    wallpaper.translate(0, dist, reps=reps2)
734
735    return wallpaper
736
737
738def wallpaper_p3m1(
739    generator: Union[Batch, Shape, Tag],
740    center_point: Point,
741    hex_size: float,
742    reps1: int = 4,
743    reps2: int = 4,
744) -> Batch:
745    """
746    Mirror and three rotations.
747    IUC: p3m1
748    Conway : *333
749    Hexagonal lattice
750    Point group: D3
751
752    Args:
753        generator (Union[Batch, Shape, Tag]): The repeating motif.
754        center_point (Point): The center point for the symmetry.
755        hex_size (float): The size of the hexagons.
756        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
757        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
758
759    Returns:
760        Batch: The resulting pattern as a Batch object.
761    """
762    x, y = center_point[:2]
763    mirror_line = line_through_point_and_angle((x, y), 2 * pi / 3)
764    wallpaper = generator.mirror(mirror_line, reps=1)
765    wallpaper.rotate(2 * pi / 3, center_point, reps=2)
766    cover_hex(wallpaper, hex_size, reps1=reps1, reps2=reps2, flat=True)
767
768    return wallpaper
769
770
771def wallpaper_p31m(
772    generator: Union[Batch, Shape, Tag],
773    center_point: Point,
774    hex_size: float,
775    reps1: int = 4,
776    reps2: int = 4,
777) -> Batch:
778    """
779    Three rotations and a mirror.
780    IUC: p31m
781    Conway : 3*3
782    Hexagonal lattice
783    Point group: D3
784
785    Args:
786        generator (Union[Batch, Shape, Tag]): The repeating motif.
787        center_point (Point): The center point for the symmetry.
788        hex_size (float): The size of the hexagons.
789        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
790        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
791
792    Returns:
793        Batch: The resulting pattern as a Batch object.
794    """
795    x, y = center_point[:2]
796    dy = 0.28866 * hex_size
797    mirror_line = ((x, y + dy), (x + 1, y + dy))
798    wallpaper = generator.rotate(2 * pi / 3, center_point, reps=2)
799    wallpaper.mirror(mirror_line, reps=1)
800
801    rotocenter = (x + hex_size / 2, y + dy)
802    wallpaper.rotate(2 * pi / 3, rotocenter, reps=2)
803    cover_hex(wallpaper, hex_size, reps1=reps1, reps2=reps2, flat=True)
804
805    return wallpaper
806
807
808def wallpaper_p6m(
809    generator: Union[Batch, Shape, Tag],
810    rotocenter: Point,
811    mirror_cross: Point,
812    hex_size: float,
813    reps1: int = 4,
814    reps2: int = 4,
815    flat_hex: bool = False,
816) -> Batch:
817    """
818    Kaleidoscope.
819    IUC: p6m(p6mm)
820    Conway : *632
821    Hexagonal lattice
822    Point group: D6
823
824    Args:
825        generator (Union[Batch, Shape, Tag]): The repeating motif.
826        rotocenter (Point): The center of rotation.
827        mirror_cross (Point): The point where the mirror lines cross.
828        hex_size (float): The size of the hexagons.
829        reps1 (int, optional): Number of repetitions in the x direction. Defaults to 4.
830        reps2 (int, optional): Number of repetitions in the y direction. Defaults to 4.
831        flat_hex (bool, optional): If True, hexagons are flat-topped. Defaults to False.
832
833    Returns:
834        Batch: The resulting pattern as a Batch object.
835    """
836    x, y = mirror_cross[:2]
837    mirror1 = [(x, y), (x + 1, y)]
838    mirror2 = [(x, y), (x, y + 1)]
839    wallpaper = generator.mirror(mirror1, reps=1)
840    wallpaper.mirror(mirror2, reps=1)
841    wallpaper.rotate(pi / 3, rotocenter, reps=5)
842    wallpaper = wallpaper.merge_shapes(1, n_round=0)
843    if flat_hex:
844        cover_hex_flat(wallpaper, hex_size, reps1=reps1, reps2=reps2)
845    else:
846        cover_hex_pointy(wallpaper, hex_size, reps1=reps1, reps2=reps2)
847
848    return wallpaper