"""
Functionalities to create decomposed cutouts of graphics created with the pytamaro library.
Functions to extract leaf elements from complex graphics, generate dotted lines for cutting guides,
and display the graphic in a format suitable for printing.
"""
from typing import List
from pytamaro import (
    Graphic, Color, Primitive, rgb_color,
    rectangle, circular_sector, transparent, overlay,
    beside, rotate, compose, pin,
    bottom_right, bottom_left, above,
    show_graphic, empty_graphic
)

def _extract_elements(graphic: Graphic, leafs: List[Graphic]):
    """
    Given a graphic, this function will extract all the leaf elements from it in a recursive way.

    A leaf element is a primitive graphic (like a rectangle, circle, etc.)
    that is not composed of other graphics.

    :param graphic: the graphic to extract the leaf elements from
    :param leafs: a list to store the leaf elements
    """
    # base case: if the graphic is a leaf, return it
    if isinstance(graphic, Primitive):
        leafs.append(graphic)
    else:
        # recursive case: if the graphic is a composition, visit its children
        # find all the attributes of type graphic and call the function recursively
        for attr_name in dir(graphic):
            if not attr_name.startswith("__") and not attr_name == "composed_graphic":
                attr = getattr(graphic, attr_name)
                if isinstance(attr, Graphic):
                    _extract_elements(attr, leafs)


def _dotted_line(width: float, horizontal: bool) -> Graphic:
    """
    Create a dotted line with a given width and orientation.

    The dotted line is composed of a series of dashes separated by gaps.

    :param width: the width of the dotted line
    :param horizontal: if True, the dotted line will be horizontal, otherwise vertical
    :return: a graphic representing the dotted line
    """
    gap_width = 25
    dash_width = 20
    dash_height = 5
    num_dashes = int(width / (gap_width + dash_width))
    dash_color = rgb_color(155, 155, 155)
    dotted_line = rectangle(0, 0, transparent)
    for _ in range(num_dashes):
        dotted_line = beside(
            dotted_line,
            beside(
                rectangle(dash_width, dash_height, dash_color),
                rectangle(gap_width, dash_height, transparent)
            )
        )
    return rotate(90, dotted_line) if not horizontal else dotted_line


def show_cutouts(graphic: Graphic):
    """
    Given a graphic, this function will show a decomposition into its parts
    that is easy to print and to cut out.
    
    The graphic will be divided into A4 pages in landscape mode.
    This function tries to divide the graphic into horizontal rows of similar height elements.

    The ratio between pixels and millimeters is approx. 10 pixels = 1 mm.

    :param graphic: the graphic to decompose
    """
    leafs = []
    _extract_elements(graphic, leafs)
    # No elements to save
    if len(leafs) == 0:
        show_graphic(empty_graphic())
        return
    # order the leafs by height
    leafs.sort(key=lambda x: x.size().height(), reverse=True)
    # A4 paper in landscape mode has a width of 297 mm (about 11.7 inches)
    # and a height of 210 mm (about 8.3 inches).
    # To approx. have the 10 pixel = 1 mm, we use 254 dpi
    dpi = 254
    max_width = 11.7 * dpi
    max_height = 8.3 * dpi
    paper_sheet = rectangle(max_width, max_height, transparent)
    current_height = leafs[0].size().height()
    final_graphics = [_dotted_line(max_width, True)]
    current_idx = 1
    final_graphics.append(
        compose(
            pin(bottom_right, _dotted_line(current_height, False)),
            pin(bottom_left, leafs[0])
        )
    )
    # compose the leafs horizontally until we reach the maximum width
    # then start a new graphic
    for leaf in leafs[1:]:
        # if the leaf color is white or close to white, add a gray background
        if leaf.color.red > 240 and leaf.color.green > 240 and leaf.color.blue > 240:
            leaf = overlay(
                leaf,
                rectangle(leaf.size().width(), leaf.size().height(), rgb_color(232, 232, 232))
            )
        # add the graphic to the row if the current leaf fits in the current graphic AND
        # the next leaf is at least half of the current leaf height (to avoid a lot of empty space)
        if (final_graphics[current_idx].size().width() + leaf.size().width() < max_width and
            leaf.size().height() > final_graphics[current_idx].size().height() / 2):
            final_graphics[current_idx] = compose(
                pin(bottom_right, final_graphics[current_idx]),
                pin(
                    bottom_left,
                    compose(
                        pin(bottom_right, _dotted_line(current_height, False)),
                        pin(bottom_left, leaf),
                    )
                )
            )
        else:
            # add the last vertical dotted line
            final_graphics[current_idx] = compose(
                pin(bottom_right, final_graphics[current_idx]),
                pin(bottom_left, _dotted_line(current_height, False))
            )
            # add the horizontal dotted line below the current row of leafs
            final_graphics[current_idx] = above(
                final_graphics[current_idx],
                _dotted_line(max_width, True)
            )
            # start a new graphic (row)
            current_idx += 1
            current_height = leaf.size().height()
            final_graphics.append(_dotted_line(current_height, False))
            final_graphics[current_idx] = compose(
                pin(bottom_right, final_graphics[current_idx]),
                pin(bottom_left, leaf)
            )
    # add the last vertical dotted line
    final_graphics[current_idx] = compose(
        pin(bottom_right, final_graphics[current_idx]),
        pin(bottom_left, _dotted_line(current_height, False))
    )
    # add the last horizontal dotted line
    final_graphics[current_idx] = above(final_graphics[current_idx], _dotted_line(max_width, True))
    # now put all the final_graphics above each other
    # if we reach the maximum height, we start a new graphic (page)
    resulting_graphics = [final_graphics[0]]
    current_idx = 0
    for graphic in final_graphics[1:]:
        if resulting_graphics[current_idx].size().height() + graphic.size().height() < max_height:
            resulting_graphics[current_idx] = above(resulting_graphics[current_idx], graphic)
        else:
            current_idx += 1
            # add the horizontal dotted line above the new graphic
            resulting_graphics.append(_dotted_line(max_width, True))
            resulting_graphics[current_idx] = above(resulting_graphics[current_idx], graphic)
    # show the resulting graphics (pages)
    for g in resulting_graphics:
        show_graphic(overlay(g, paper_sheet))


def rounded_rectangle(width: float, height: float) -> Graphic:
    """
    This produces a simple graphic (a black rounded rectangle) for demo purposes
    :param width: the width of the rounded rectangle
    :param height: the height of the rounded rectangle
    """
    corner_radius = min(width, height) / 4
    color = rgb_color(128, 128, 128)
    def rounded_edge(width: float, corner_radius: float, color: Color) -> Graphic:
        return beside(
            rotate(90, circular_sector(corner_radius, 90, color)),
            beside(
                rectangle(width - 2 * corner_radius, corner_radius, color),
                circular_sector(corner_radius, 90, color)
            )
        )

    return above(
        rounded_edge(width, corner_radius, color),
        above(
            rectangle(width, height - 2 * corner_radius, color),
            rotate(180, rounded_edge(width, corner_radius, color))
        )
    )


Paper Cutouts

Generate your graphic

Output images of the cutouts

Download, print, and cut

Printing multiple copies