simetri.tikz.tikz

   1"""TikZ exporter. Draws shapes using the TikZ package for LaTeX.
   2Sketch objects are converted to TikZ code."""
   3
   4# This is a proof of concept.
   5# To do: This whole module needs to be restructured.
   6
   7from __future__ import annotations
   8
   9from math import degrees, cos, sin, ceil
  10from typing import List, Union
  11from dataclasses import dataclass, field
  12
  13import numpy as np
  14
  15import simetri.graphics as sg
  16from ..graphics.common import common_properties
  17from ..graphics.all_enums import (
  18    BackStyle,
  19    FontSize,
  20    FontFamily,
  21    MarkerType,
  22    ShadeType,
  23    Types,
  24    TexLoc,
  25    FrameShape,
  26    DocumentClass,
  27    Align,
  28    ArrowLine,
  29    BlendMode,
  30    get_enum_value,
  31    LineWidth,
  32    LineDashArray,
  33)
  34from ..canvas.style_map import shape_style_map, line_style_map, marker_style_map
  35from ..settings.settings import defaults, tikz_defaults
  36from ..geometry.geometry import homogenize, close_points2, round_point
  37from ..geometry.ellipse import ellipse_point
  38from ..graphics.sketch import TagSketch, ShapeSketch
  39from ..graphics.shape import Shape
  40
  41from ..colors.colors import Color
  42
  43
  44np.set_printoptions(legacy="1.21")
  45array = np.array
  46
  47
  48enum_map = {}
  49
  50
  51def scope_code_required(item: Union["Canvas", "Batch"]) -> bool:
  52    """Check if a TikZ namespace is required for the item.
  53
  54    Args:
  55        item (Union["Canvas", "Batch"]): The item to check.
  56
  57    Returns:
  58        bool: True if a TikZ namespace is required, False otherwise.
  59    """
  60    return (
  61        item.blend_mode is not None
  62        or item.transparency_group
  63        or (item.clip and item.mask)
  64    )
  65
  66
  67@dataclass
  68class Tex:
  69    """Tex class for generating tex code.
  70
  71    Attributes:
  72        begin_document (str): The beginning of the document.
  73        end_document (str): The end of the document.
  74        begin_tikz (str): The beginning of the TikZ environment.
  75        end_tikz (str): The end of the TikZ environment.
  76        packages (List[str]): List of required TeX packages.
  77        tikz_libraries (List[str]): List of required TikZ libraries.
  78        tikz_code (str): The generated TikZ code.
  79        sketches (List["Sketch"]): List of Sketch objects.
  80    """
  81
  82    begin_document: str = defaults["begin_doc"]
  83    end_document: str = defaults["end_doc"]
  84    begin_tikz: str = defaults["begin_tikz"]
  85    end_tikz: str = defaults["end_tikz"]
  86    packages: List[str] = None
  87    tikz_libraries: List[str] = None
  88    tikz_code: str = ""  # Generated by the canvas by using sketches
  89    sketches: List["Sketch"] = field(default_factory=list)  # List of TexSketch objects
  90
  91    def __post_init__(self):
  92        """Post-initialization method."""
  93        self.type = Types.TEX
  94        common_properties(self)
  95
  96    def tex_code(self, canvas: "Canvas", aux_code: str) -> str:
  97        """Generate the final TeX code.
  98
  99        Args:
 100            canvas ("Canvas"): The canvas object.
 101            aux_code (str): Auxiliary code to include.
 102
 103        Returns:
 104            str: The final TeX code.
 105        """
 106        doc_code = []
 107        for sketch in self.sketches:
 108            if sketch.location == TexLoc.DOCUMENT:
 109                doc_code.append(sketch.code)
 110        doc_code = "\n".join(doc_code)
 111        back_color = f"\\pagecolor{color2tikz(canvas.back_color)}"
 112        self.begin_document = self.begin_document + back_color + "\n"
 113        if canvas.limits is not None:
 114            begin_tikz = self.begin_tikz + get_limits_code(canvas) + "\n"
 115        else:
 116            begin_tikz = self.begin_tikz + "\n"
 117        if scope_code_required(canvas):
 118            scope = get_canvas_scope(canvas)
 119            code = (
 120                self.get_preamble(canvas)
 121                + self.begin_document
 122                + doc_code
 123                + begin_tikz
 124                + scope
 125                + self.get_tikz_code()
 126                + aux_code
 127                + "\\end{scope}\n"
 128                + self.end_tikz
 129                + self.end_document
 130            )
 131        else:
 132            code = (
 133                self.get_preamble(canvas)
 134                + self.begin_document
 135                + doc_code
 136                + begin_tikz
 137                + self.get_tikz_code()
 138                + aux_code
 139                + self.end_tikz
 140                + self.end_document
 141            )
 142
 143        return code
 144
 145    def get_doc_class(self, border: float, font_size: int) -> str:
 146        """Returns the document class.
 147
 148        Args:
 149            border (float): The border size.
 150            font_size (int): The font size.
 151
 152        Returns:
 153            str: The document class string.
 154        """
 155        return f"\\documentclass[{font_size}pt,tikz,border={border}pt]{{standalone}}\n"
 156
 157    def get_tikz_code(self) -> str:
 158        """Returns the TikZ code.
 159
 160        Returns:
 161            str: The TikZ code.
 162        """
 163        code = ""
 164        for sketch in self.sketches:
 165            if sketch.location == TexLoc.PICTURE:
 166                code += sketch.text + "\n"
 167
 168        return code
 169
 170    def get_tikz_libraries(self) -> str:
 171        """Returns the TikZ libraries.
 172
 173        Returns:
 174            str: The TikZ libraries string.
 175        """
 176        return f"\\usetikzlibrary{{{','.join(self.tikz_libraries)}}}\n"
 177
 178    def get_packages(self, canvas) -> str:
 179        """Returns the required TeX packages.
 180
 181        Args:
 182            canvas: The canvas object.
 183
 184        Returns:
 185            str: The required TeX packages.
 186        """
 187        tikz_libraries = []
 188        tikz_packages = ['tikz', 'pgf']
 189        for page in canvas.pages:
 190            for sketch in page.sketches:
 191                if hasattr(sketch, "draw_frame") and sketch.draw_frame:
 192                    if hasattr(sketch, "frame_shape") and sketch.frame_shape != FrameShape.RECTANGLE:
 193                        if "shapes.geometric" not in tikz_libraries:
 194                            tikz_libraries.append("shapes.geometric")
 195                if sketch.draw_markers:
 196                    if 'patterns' not in tikz_libraries:
 197                        tikz_libraries.append("patterns")
 198                        tikz_libraries.append("patterns.meta")
 199                        tikz_libraries.append("backgrounds")
 200                        tikz_libraries.append("shadings")
 201                if sketch.line_dash_array:
 202                    if 'patterns' not in tikz_libraries:
 203                        tikz_libraries.append("patterns")
 204                if sketch.subtype == Types.TAG_SKETCH:
 205                    if "fontspec" not in tikz_packages:
 206                        tikz_packages.append("fontspec")
 207                else:
 208                    if hasattr(sketch, "marker_type") and sketch.marker_type == "indices":
 209                        if "fontspec" not in tikz_packages:
 210                            tikz_packages.append("fontspec")
 211                if hasattr(sketch, 'back_style'):
 212                    if sketch.back_style == BackStyle.COLOR:
 213                        if "xcolor" not in tikz_packages:
 214                            tikz_packages.append("xcolor")
 215                    if sketch.back_style == BackStyle.SHADING:
 216                        if "shadings" not in tikz_libraries:
 217                            tikz_libraries.append("shadings")
 218                    if sketch.back_style == BackStyle.PATTERN:
 219                        if "patterns" not in tikz_libraries:
 220                            tikz_libraries.append("patterns")
 221                            tikz_libraries.append("patterns.meta")
 222
 223
 224        return tikz_libraries, tikz_packages
 225
 226    def get_preamble(self, canvas) -> str:
 227        """Returns the TeX preamble.
 228
 229        Args:
 230            canvas: The canvas object.
 231
 232        Returns:
 233            str: The TeX preamble.
 234        """
 235        libraries, packages = self.get_packages(canvas)
 236
 237        if packages:
 238            packages = f'\\usepackage{{{",".join(packages)}}}\n'
 239            if 'fontspec' in packages:
 240                fonts_section = f"""\\setmainfont{{{defaults['main_font']}}}
 241\\setsansfont{{{defaults['sans_font']}}}
 242\\setmonofont{{{defaults['mono_font']}}}\n"""
 243
 244        if libraries:
 245            libraries = f'\\usetikzlibrary{{{",".join(libraries)}}}\n'
 246
 247        if canvas.border is None:
 248            border = defaults["border"]
 249        elif isinstance(canvas.border, (int, float)):
 250            border = canvas.border
 251        else:
 252            raise ValueError("Canvas.border must be a positive numeric value.")
 253        if border < 0:
 254            raise ValueError("Canvas.border must be a positive numeric value.")
 255        doc_class = self.get_doc_class(border, defaults["font_size"])
 256        # Check if different fonts are used
 257        fonts_section = ""
 258        fonts = canvas.get_fonts_list()
 259        for font in fonts:
 260            if font is None:
 261                continue
 262            font_family = font.replace(" ", "")
 263            fonts_section += f"\\newfontfamily\\{font_family}[Scale=1.0]{{{font}}}\n"
 264        preamble = f"{doc_class}{packages}{libraries}{fonts_section}"
 265
 266        indices = False
 267        for sketch in canvas.active_page.sketches:
 268            if hasattr(sketch, "marker_type") and sketch.marker_type == "indices":
 269                indices = True
 270                break
 271        if indices:
 272            font_family = defaults["indices_font_family"]
 273            font_size = defaults["indices_font_size"]
 274            count = 0
 275            for sketch in canvas.active_page.sketches:
 276                if hasattr(sketch, "marker_type") and sketch.marker_type == "indices":
 277                    preamble += "\\tikzset{\n"
 278                    node_style = (
 279                        f"nodestyle{count}/.style={{draw, circle, gray, "
 280                        f"text=black, fill=white, line width = .5, inner sep=.5, "
 281                        f"font=\\{font_family}\\{font_size}}}\n}}\n"
 282                    )
 283                    preamble += node_style
 284                    count += 1
 285        for sketch in canvas.active_page.sketches:
 286            if sketch.subtype == Types.TEX_SKETCH:
 287                if sketch.location == TexLoc.PREAMBLE:
 288                    preamble += sketch.code + "\n"
 289        return preamble
 290
 291
 292def get_back_grid_code(grid: Grid, canvas: "Canvas") -> str:
 293    """Page background grid code.
 294
 295    Args:
 296        grid (Grid): The grid object.
 297        canvas ("Canvas"): The canvas object.
 298
 299    Returns:
 300        str: The background grid code.
 301    """
 302    # \usetikzlibrary{backgrounds}
 303    # \begin{scope}[on background layer]
 304    # \fill[gray] (current bounding box.south west) rectangle
 305    # (current bounding box.north east);
 306    # \draw[white,step=.5cm] (current bounding box.south west) grid
 307    # (current bounding box.north east);
 308    # \end{scope}
 309    grid = canvas.active_page.grid
 310    back_color = color2tikz(grid.back_color)
 311    line_color = color2tikz(grid.line_color)
 312    step = grid.spacing
 313    lines = ["\\begin{scope}[on background layer]\n"]
 314    lines.append(f"\\fill[color={back_color}] (current bounding box.south west) ")
 315    lines.append("rectangle (current bounding box.north east);\n")
 316    options = []
 317    if grid.line_dash_array is not None:
 318        options.append(f"dashed, dash pattern={get_dash_pattern(grid.line_dash_array)}")
 319    if grid.line_width is not None:
 320        options.append(f"line width={grid.line_width}")
 321    if options:
 322        options = ",".join(options)
 323        lines.append(f"\\draw[color={line_color}, step={step}, {options}]")
 324    else:
 325        lines.append(f"\\draw[color={line_color},step={step}]")
 326    lines.append("(current bounding box.south west)")
 327    lines.append(" grid (current bounding box.north east);\n")
 328    lines.append("\\end{scope}\n")
 329
 330    return "".join(lines)
 331
 332
 333def get_limits_code(canvas: "Canvas") -> str:
 334    """Get the limits of the canvas for clipping.
 335
 336    Args:
 337        canvas ("Canvas"): The canvas object.
 338
 339    Returns:
 340        str: The limits code for clipping.
 341    """
 342    xmin, ymin, xmax, ymax = canvas.limits
 343    points = [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)]
 344    vertices = homogenize(points) @ canvas.xform_matrix
 345    coords = " ".join([f"({v[0]}, {v[1]})" for v in vertices])
 346
 347    return f"\\clip plot[] coordinates {{{coords}}};\n"
 348
 349
 350def get_back_code(canvas: "Canvas") -> str:
 351    """Get the background code for the canvas.
 352
 353    Args:
 354        canvas ("Canvas"): The canvas object.
 355
 356    Returns:
 357        str: The background code.
 358    """
 359    back_color = color2tikz(canvas.back_color)
 360    return f"\\pagecolor{back_color}\n"
 361
 362
 363def get_tex_code(canvas: "Canvas") -> str:
 364    """Convert the sketches in the Canvas to TikZ code.
 365
 366    Args:
 367        canvas ("Canvas"): The canvas object.
 368
 369    Returns:
 370        str: The TikZ code.
 371    """
 372
 373    def get_sketch_code(sketch, canvas, ind):
 374        """Get the TikZ code for a sketch.
 375
 376        Args:
 377            sketch: The sketch object.
 378            canvas: The canvas object.
 379            ind: The index.
 380
 381        Returns:
 382            tuple: The TikZ code and the updated index.
 383        """
 384        if sketch.subtype == Types.TAG_SKETCH:
 385            code = draw_tag_sketch(sketch)
 386        elif sketch.subtype == Types.BBOX_SKETCH:
 387            code = draw_bbox_sketch(sketch)
 388        elif sketch.subtype == Types.PATTERN_SKETCH:
 389            code = draw_pattern_sketch(sketch)
 390        elif sketch.subtype == Types.TEX_SKETCH:
 391            if sketch.location == TexLoc.NONE:
 392                code = sketch.code
 393        else:
 394            if sketch.draw_markers and sketch.marker_type == MarkerType.INDICES:
 395                code = draw_shape_sketch(sketch, ind)
 396                ind += 1
 397            else:
 398                code = draw_shape_sketch(sketch)
 399
 400        return code, ind
 401
 402    pages = canvas.pages
 403
 404    if pages:
 405        for i, page in enumerate(pages):
 406            sketches = page.sketches
 407            back_color = f"\\pagecolor{color2tikz(page.back_color)}"
 408            if i == 0:
 409                code = [back_color]
 410            else:
 411                code.append(defaults["end_tikz"])
 412                code.append("\\newpage")
 413                code.append(defaults["begin_tikz"])
 414            ind = 0
 415            for sketch in sketches:
 416                sketch_code, ind = get_sketch_code(sketch, canvas, ind)
 417                code.append(sketch_code)
 418
 419        code = "\n".join(code)
 420    else:
 421        raise ValueError("No pages found in the canvas.")
 422    return canvas.tex.tex_code(canvas, code)
 423
 424
 425class Grid(sg.Shape):
 426    """Grid shape.
 427
 428    Args:
 429        p1: (x_min, y_min)
 430        p2: (x_max, y_max)
 431        dx: x step
 432        dy: y step
 433    """
 434
 435    def __init__(self, p1, p2, dx, dy, **kwargs):
 436        """
 437        Args:
 438            p1: (x_min, y_min)
 439            p2: (x_max, y_max)
 440            dx: x step
 441            dy: y step
 442        """
 443        self.p1 = p1
 444        self.p2 = p2
 445        self.dx = dx
 446        self.dy = dy
 447        self.primary_points = sg.Points([p1, p2])
 448        self.closed = False
 449        self.fill = False
 450        self.stroke = True
 451        self._b_box = None
 452        super().__init__([p1, p2], xform_matrix=None, subtype=sg.Types.GRID, **kwargs)
 453
 454
 455def get_min_size(sketch: ShapeSketch) -> str:
 456    """Returns the minimum size of the tag node.
 457
 458    Args:
 459        sketch (ShapeSketch): The shape sketch object.
 460
 461    Returns:
 462        str: The minimum size of the tag node.
 463    """
 464    options = []
 465    if sketch.frame_shape == "rectangle":
 466        if sketch.frame_min_width is None:
 467            width = defaults["min_width"]
 468        else:
 469            width = sketch.frame_min_width
 470        if sketch.frame_min_height is None:
 471            height = defaults["min_height"]
 472        else:
 473            height = sketch.frame_min_height
 474        options.append(f"minimum width = {width}")
 475        options.append(f"minimum height = {height}")
 476    else:
 477        if sketch.frame_min_size is None:
 478            min_size = defaults["min_size"]
 479        else:
 480            min_size = sketch.frame_min_size
 481        options.append(f"minimum size = {min_size}")
 482
 483    return options
 484
 485
 486def frame_options(sketch: TagSketch) -> List[str]:
 487    """Returns the options for the frame of the tag node.
 488
 489    Args:
 490        sketch (TagSketch): The tag sketch object.
 491
 492    Returns:
 493        List[str]: The options for the frame of the tag node.
 494    """
 495    options = []
 496    if sketch.draw_frame:
 497        options.append(sketch.frame_shape)
 498        line_options = get_line_style_options(sketch, frame=True)
 499        if line_options:
 500            options.extend(line_options)
 501        fill_options = get_fill_style_options(sketch, frame=True)
 502        if fill_options:
 503            options.extend(fill_options)
 504        if sketch.text in [None, ""]:
 505            min_size = get_min_size(sketch)
 506            if min_size:
 507                options.extend(min_size)
 508
 509    return options
 510
 511
 512def color2tikz(color):
 513    """Converts a Color object to a TikZ color string.
 514
 515    Args:
 516        color (Color): The color object.
 517
 518    Returns:
 519        str: The TikZ color string.
 520    """
 521    # \usepackage{xcolor}
 522    # \tikz\node[rounded corners, fill={rgb,255:red,21; green,66; blue,128},
 523    #                                    text=white, draw=black] {hello world};
 524    # \definecolor{mycolor}{rgb}{1,0.2,0.3}
 525    # \definecolor{mycolor}{R_g_b}{255,51,76}
 526    # \definecolor{mypink1}{rgb}{0.858, 0.188, 0.478}
 527    # \definecolor{mypink2}{R_g_b}{219, 48, 122}
 528    # \definecolor{mypink3}{cmyk}{0, 0.7808, 0.4429, 0.1412}
 529    # \definecolor{mygray}{gray}{0.6}
 530    if color is None:
 531        r, g, b, _ = 255, 255, 255, 255
 532        return f"{{rgb,255:red,{r}; green,{g}; blue,{b}}}"
 533    r, g, b = color.rgb255
 534
 535    return f"{{rgb,255:red,{r}; green,{g}; blue,{b}}}"
 536
 537
 538def get_scope_options(item: Union["Canvas", "Sketch"]) -> str:
 539    """Used for creating namespaces in TikZ.
 540
 541    Args:
 542        item (Union["Canvas", "Sketch"]): The item to get scope options for.
 543
 544    Returns:
 545        str: The scope options as a string.
 546    """
 547    options = []
 548
 549    if item.blend_group:
 550        options.append(f"blend group={item.blend_mode}")
 551    elif item.blend_mode:
 552        options.append(f"blend mode={item.blend_mode}")
 553    if item.fill_alpha not in [None, 1]:
 554        options.append(f"fill opacity={item.fill_alpha}")
 555    if item.line_alpha not in [None, 1]:
 556        options.append(f"draw opacity={item.line_alpha}")
 557    if item.text_alpha not in [None, 1]:
 558        options.append(f"text opacity={item.alpha}")
 559    if item.alpha not in [None, 1]:
 560        options.append(f"opacity={item.alpha}")
 561    if item.even_odd_rule:
 562        options.append("even odd rule")
 563    if item.transparency_group:
 564        options.append("transparency group")
 565
 566    return ",".join(options)
 567
 568
 569def get_clip_code(item: Union["Sketch", "Canvas"]) -> str:
 570    """Returns the clip code for a sketch or Canvas.
 571
 572    Args:
 573        item (Union["Sketch", "Canvas"]): The item to get clip code for.
 574
 575    Returns:
 576        str: The clip code as a string.
 577    """
 578    if item.mask.subtype == Types.CIRCLE:
 579        x, y = item.mask.center[:2]
 580        res = f"\\clip({x}, {y}) circle ({item.mask.radius});\n"
 581    elif item.mask.subtype == Types.RECTANGLE:
 582        x, y = item.mask.center[:2]
 583        width, height = item.mask.width, item.mask.height
 584        res = f"\\clip({x}, {y}) rectangle ({width}, {height});\n"
 585    elif item.mask.subtype == Types.SHAPE:
 586        # vertices = item.mask.primary_points.homogen_coords
 587        # coords = " ".join([f"({v[0]}, {v[1]})" for v in vertices])
 588        # res = f"\\clip plot[] coordinates {{{coords}}};\n"
 589        x, y = item.mask.origin[:2]
 590        width, height = item.mask.width, item.mask.height
 591        res = f"\\clip({x}, {y}) rectangle ({width}, {height});\n"
 592    else:
 593        res = ""
 594
 595    return res
 596
 597
 598def get_canvas_scope(canvas):
 599    """Returns the TikZ code for the canvas scope.
 600
 601    Args:
 602        canvas: The canvas object.
 603
 604    Returns:
 605        str: The TikZ code for the canvas scope.
 606    """
 607    options = get_scope_options(canvas)
 608    res = f"\\begin{{scope}}[{options}]\n"
 609    if (canvas.clip and canvas.mask) or canvas.size is not None:
 610        res += get_clip_code(canvas)
 611
 612    return res
 613
 614
 615def draw_batch_sketch(sketch, canvas):
 616    """Converts a BatchSketch to TikZ code.
 617
 618    Args:
 619        sketch: The BatchSketch object.
 620        canvas: The canvas object.
 621
 622    Returns:
 623        str: The TikZ code for the BatchSketch.
 624    """
 625    options = get_scope_options(sketch)
 626    if options:
 627        res = f"\\begin{{scope}}[{options}]\n"
 628    else:
 629        res = ""
 630    if sketch.clip and sketch.mask:
 631        res += get_clip_code(sketch)
 632    for item in sketch.items:
 633        if item.subtype in d_sketch_draw:
 634            res += d_sketch_draw[item.subtype](item, canvas)
 635        else:
 636            raise ValueError(f"Sketch type {item.subtype} not supported.")
 637
 638    if sketch.clip and sketch.mask:
 639        res += get_clip_code(sketch)
 640    if options:
 641        res += "\\end{scope}\n"
 642
 643    return res
 644
 645def draw_bbox_sketch(sketch):
 646    """Converts a BBoxSketch to TikZ code.
 647
 648    Args:
 649        sketch: The BBoxSketch object.
 650        canvas: The canvas object.
 651
 652    Returns:
 653        str: The TikZ code for the BBoxSketch.
 654    """
 655    attrib_map = {
 656        "line_color": "color",
 657        "line_width": "line width",
 658        "line_dash_array": "dash pattern",
 659    }
 660    attrib_list = ["line_color", "line_width", "line_dash_array"]
 661    options = sg_to_tikz(sketch, attrib_list, attrib_map)
 662    options = ", ".join(options)
 663    res = f"\\draw[{options}]"
 664    x1, y1 = sketch.vertices[1]
 665    x2, y2 = sketch.vertices[3]
 666    res += f"({x1}, {y1}) rectangle ({x2}, {y2});\n"
 667
 668    return res
 669
 670def draw_lace_sketch(item):
 671    """Converts a LaceSketch to TikZ code.
 672
 673    Args:
 674        item: The LaceSketch object.
 675
 676    Returns:
 677        str: The TikZ code for the LaceSketch.
 678    """
 679    if item.draw_fragments:
 680        for fragment in item.fragments:
 681            draw_shape_sketch(fragment)
 682    if item.draw_plaits:
 683        for plait in item.plaits:
 684            plait.fill = True
 685            draw_shape_sketch(plait)
 686
 687
 688def get_draw(sketch):
 689    """Returns the draw command for sketches.
 690
 691    Args:
 692        sketch: The sketch object.
 693
 694    Returns:
 695        str: The draw command as a string.
 696    """
 697    # sketch.closed, sketch.fill, sketch.stroke, shading
 698    decision_table = {
 699        (True, True, True, True): "\\shadedraw",
 700        (True, True, True, False): "\\filldraw",
 701        (True, True, False, True): "\\shade",
 702        (True, True, False, False): "\\fill",
 703        (True, False, True, True): "\\draw",
 704        (True, False, True, False): "\\draw",
 705        (True, False, False, True): False,
 706        (True, False, False, False): False,
 707        (False, True, True, True): "\\draw",
 708        (False, True, True, False): "\\draw",
 709        (False, True, False, True): False,
 710        (False, True, False, False): False,
 711        (False, False, True, True): "\\draw",
 712        (False, False, True, False): "\\draw",
 713        (False, False, False, True): False,
 714        (False, False, False, False): False,
 715    }
 716    if sketch.markers_only:
 717        res = "\\draw"
 718    else:
 719        if hasattr(sketch, 'back_style'):
 720            shading = sketch.back_style == BackStyle.SHADING
 721        else:
 722            shading = False
 723        if not hasattr(sketch, 'closed'):
 724            closed = False
 725        else:
 726            closed = sketch.closed
 727        if not hasattr(sketch, 'fill'):
 728            fill = False
 729        else:
 730            fill = sketch.fill
 731        if not hasattr(sketch, 'stroke'):
 732            stroke = False
 733        else:
 734            stroke = sketch.stroke
 735
 736        res = decision_table[(closed, fill, stroke, shading)]
 737
 738    return res
 739
 740
 741def get_frame_options(sketch):
 742    """Returns the options for the frame of a TagSketch.
 743
 744    Args:
 745        sketch: The TagSketch object.
 746
 747    Returns:
 748        list: The options for the frame of the TagSketch.
 749    """
 750    options = get_line_style_options(sketch)
 751    options += get_fill_style_options(sketch)
 752    if sketch.text in [None, ""]:
 753        if sketch.frame.frame_shape == "rectangle":
 754            width = sketch.frame.min_width
 755            height = sketch.frame.min_height
 756            if not width:
 757                width = defaults["min_width"]
 758            if not height:
 759                height = defaults["min_height"]
 760            options += "minimum width = {width}, minimum height = {height}"
 761        else:
 762            size = sketch.frame.min_size
 763            if not size:
 764                size = defaults["min_size"]
 765            options += f"minimum size = {size}"
 766    return options
 767
 768
 769def draw_tag_sketch(sketch):
 770    """Converts a TagSketch to TikZ code.
 771
 772    Args:
 773        sketch: The TagSketch object.
 774        canvas: The canvas object.
 775
 776    Returns:
 777        str: The TikZ code for the TagSketch.
 778    """
 779    # \node at (0,0) {some text};
 780    def get_font_family(sketch):
 781        default_fonts = [defaults['main_font'], defaults['sans_font'], defaults['mono_font']]
 782
 783        if sketch.font_family in default_fonts:
 784            if sketch.font_family == defaults['main_font']:
 785                res = 'tex_family', ''
 786            elif sketch.font_family == defaults['sans_font']:
 787                res = 'tex_family', 'textsf'
 788            else: # defaults['mono_font']
 789                res = 'tex_family', 'texttt'
 790        elif sketch.font_family:
 791            if isinstance(sketch.font_family, FontFamily):
 792                if sketch.font_family == FontFamily.SANSSERIF:
 793                    res = 'tex_family', 'textsf'
 794                elif sketch.font_family == FontFamily.MONOSPACE:
 795                    res = 'tex_family', 'texttt'
 796                else:
 797                    res = 'tex_family', 'textrm'
 798
 799            elif isinstance(sketch.font_family, str):
 800                res = 'new_family', sketch.font_family.replace(" ", "")
 801
 802            else:
 803                raise ValueError(f"Font family {sketch.font_family} not supported.")
 804        else:
 805            res = 'no_family', None
 806
 807        return res
 808
 809    def get_font_size(sketch):
 810
 811        if sketch.font_size:
 812            if isinstance(sketch.font_size, FontSize):
 813                res = 'tex_size', sketch.font_size.value
 814            else:
 815                res = 'num_size', sketch.font_size
 816        else:
 817            res = 'no_size', None
 818
 819        return res
 820
 821    res = []
 822    x, y = sketch.pos[:2]
 823
 824    options = ""
 825    if sketch.draw_frame:
 826        options += "draw"
 827        if sketch.stroke:
 828            if sketch.frame_shape != FrameShape.RECTANGLE:
 829                options += f", {sketch.frame_shape}, "
 830            line_style_options = get_line_style_options(sketch)
 831            if line_style_options:
 832                options += ', ' + ', '.join(line_style_options)
 833            if sketch.frame_inner_sep:
 834                options += f", inner sep={sketch.frame_inner_sep}"
 835            if sketch.minimum_width:
 836                options += f", minimum width={sketch.minimum_width}"
 837            if sketch.smooth and sketch.frame_shape not in [
 838                FrameShape.CIRCLE,
 839                FrameShape.ELLIPSE,
 840            ]:
 841                options += ", smooth"
 842
 843    if sketch.fill and sketch.back_color:
 844        options += f", fill={color2tikz(sketch.frame_back_color)}"
 845    if sketch.anchor:
 846        options += f", anchor={sketch.anchor.value}"
 847    if sketch.back_style == BackStyle.SHADING and sketch.fill:
 848        shading_options = get_shading_options(sketch)[0]
 849        options += ", " + shading_options
 850    if sketch.back_style == BackStyle.PATTERN and sketch.fill:
 851        pattern_options = get_pattern_options(sketch)[0]
 852        options += ", " + pattern_options
 853    if sketch.align != defaults["tag_align"]:
 854        options += f", align={sketch.align.value}"
 855    if sketch.text_width:
 856        options += f", text width={sketch.text_width}"
 857
 858
 859# no_family, tex_family, new_family
 860# no_size, tex_size, num_size
 861
 862# num_size and new_family {\fontsize{20}{24} \selectfont \Verdana ABCDEFG Hello, World! 25}
 863# tex_size and new_family {\large{\selectfont \Verdana ABCDEFG Hello, World! 50}}
 864# no_size and new_family {\selectfont \Verdana ABCDEFG Hello, World! 50}
 865
 866# tex_family {\textsc{\textit{\textbf{\Huge{\texttt{ABCDG Just a test -50}}}}}};
 867
 868# no_family {\textsc{\textit{\textbf{\Huge{ABCDG Just a test -50}}}}};
 869
 870    if sketch.font_color is not None and sketch.font_color != defaults["font_color"]:
 871        options += f", text={color2tikz(sketch.font_color)}"
 872    family, font_family = get_font_family(sketch)
 873    size, font_size = get_font_size(sketch)
 874    tex_text = ''
 875    if sketch.small_caps:
 876        tex_text += '\\textsc{'
 877
 878    if sketch.italic:
 879        tex_text += '\\textit{'
 880
 881    if sketch.bold:
 882        tex_text += '\\textbf{'
 883
 884    if size == 'num_size':
 885        f_size = font_size
 886        f_size2 = ceil(font_size * 1.2)
 887        tex_text += f"\\fontsize{{{f_size}}}{{{f_size2}}}\\selectfont "
 888
 889    elif size == 'tex_size':
 890        tex_text += f"\\{font_size}{{\\selectfont "
 891
 892    else:
 893        tex_text += "\\selectfont "
 894
 895    if family == 'new_family':
 896        tex_text += f"\\{font_family} {sketch.text}}}"
 897
 898    elif family == 'tex_family':
 899        if font_family:
 900            tex_text += f"\\{font_family}{{ {sketch.text}}}}}"
 901        else:
 902            tex_text += f"{{ {sketch.text}}}"
 903    else: # no_family
 904        tex_text += f"{{ {sketch.text}}}"
 905
 906    tex_text = '{' + tex_text
 907
 908    open_braces = tex_text.count('{')
 909    close_braces = tex_text.count('}')
 910    tex_text = tex_text + '}' * (open_braces - close_braces)
 911
 912    res.append(f"\\node[{options}] at ({x}, {y}) {tex_text};\n")
 913
 914    return ''.join(res)
 915
 916
 917def get_dash_pattern(line_dash_array):
 918    """Returns the dash pattern for a line.
 919
 920    Args:
 921        line_dash_array: The dash array for the line.
 922
 923    Returns:
 924        str: The dash pattern as a string.
 925    """
 926    dash_pattern = []
 927    for i, dash in enumerate(line_dash_array):
 928        if i % 2 == 0:
 929            dash_pattern.extend(["on", f"{dash}pt"])
 930        else:
 931            dash_pattern.extend(["off", f"{dash}pt"])
 932
 933    return " ".join(dash_pattern)
 934
 935
 936def sg_to_tikz(sketch, attrib_list, attrib_map, conditions=None, exceptions=None):
 937    """Converts the attributes of a sketch to TikZ options.
 938
 939    Args:
 940        sketch: The sketch object.
 941        attrib_list: The list of attributes to convert.
 942        attrib_map: The map of attributes to TikZ options.
 943        conditions: Optional conditions for the attributes.
 944        exceptions: Optional exceptions for the attributes.
 945
 946    Returns:
 947        list: The TikZ options as a list.
 948    """
 949    skip = ["marker_color", "fill_color"]
 950    tikz_way = {'line_width':LineWidth, 'line_dash_array':LineDashArray}
 951    if exceptions:
 952        skip += exceptions
 953    d_converters = {
 954        "line_color": color2tikz,
 955        "fill_color": color2tikz,
 956        "draw": color2tikz,
 957        "line_dash_array": get_dash_pattern,
 958    }
 959    options = []
 960    for attrib in attrib_list:
 961        if attrib not in attrib_map:
 962            continue
 963        if conditions and attrib in conditions and not conditions[attrib]:
 964            continue
 965        if attrib in tikz_way:
 966            value = getattr(sketch, attrib)
 967            if isinstance(value, tikz_way[attrib]):
 968                option = value.value
 969                options.append(option)
 970                continue
 971            if isinstance(value, str):
 972                if value in tikz_way[attrib]:
 973                    options.append(value)
 974                continue
 975
 976        tikz_attrib = attrib_map[attrib]
 977        if hasattr(sketch, attrib):
 978            value = getattr(sketch, attrib)
 979            if value is not None and tikz_attrib in list(attrib_map.values()):
 980                if attrib in ['smooth']: # smooth is a boolean
 981                    if value:
 982                        options.append("smooth")
 983
 984                elif attrib in skip:
 985                    value = color2tikz(getattr(sketch, attrib))
 986                    options.append(f"{tikz_attrib}={value}")
 987
 988                elif value != tikz_defaults[tikz_attrib]:
 989                    if attrib in d_converters:
 990                        value = d_converters[attrib](value)
 991                    options.append(f"{tikz_attrib}={value}")
 992
 993    return options
 994
 995
 996def get_line_style_options(sketch, exceptions=None):
 997    """Returns the options for the line style.
 998
 999    Args:
1000        sketch: The sketch object.
1001        exceptions: Optional exceptions for the line style options.
1002
1003    Returns:
1004        list: The line style options as a list.
1005    """
1006    attrib_map = {
1007        "line_color": "color",
1008        "line_width": "line width",
1009        "line_dash_array": "dash pattern",
1010        "line_cap": "line cap",
1011        "line_join": "line join",
1012        "line_miter_limit": "miter limit",
1013        "line_dash_phase": "dash phase",
1014        "line_alpha": "draw opacity",
1015        "smooth": "smooth",
1016        "fillet_radius": "rounded corners",
1017    }
1018    attribs = list(line_style_map.keys())
1019    if sketch.stroke:
1020        if exceptions and "draw_fillets" not in exceptions:
1021            conditions = {"fillet_radius": sketch.draw_fillets}
1022        else:
1023            conditions = None
1024        if sketch.line_alpha not in [None, 1]:
1025            sketch.line_alpha = sketch.line_alpha
1026        elif sketch.alpha not in [None, 1]:
1027            sketch.fill_alpha = sketch.alpha
1028        else:
1029            attribs.remove("line_alpha")
1030        if not sketch.smooth:
1031            attribs.remove("smooth")
1032        res = sg_to_tikz(sketch, attribs, attrib_map, conditions, exceptions)
1033    else:
1034        res = []
1035
1036    return res
1037
1038
1039def get_fill_style_options(sketch, exceptions=None, frame=False):
1040    """Returns the options for the fill style.
1041
1042    Args:
1043        sketch: The sketch object.
1044        exceptions: Optional exceptions for the fill style options.
1045        frame: Optional flag for frame fill style.
1046
1047    Returns:
1048        list: The fill style options as a list.
1049    """
1050    attrib_map = {
1051        "fill_color": "fill",
1052        "fill_alpha": "fill opacity",
1053        #'fill_mode': 'even odd rule',
1054        "blend_mode": "blend mode",
1055        "frame_back_color": "fill",
1056    }
1057    attribs = list(shape_style_map.keys())
1058    if sketch.fill_alpha not in [None, 1]:
1059        sketch.fill_alpha = sketch.fill_alpha
1060    elif sketch.alpha not in [None, 1]:
1061        sketch.fill_alpha = sketch.alpha
1062    else:
1063        attribs.remove("fill_alpha")
1064    if sketch.fill and not sketch.back_style == BackStyle.PATTERN:
1065        res = sg_to_tikz(sketch, attribs, attrib_map, exceptions=exceptions)
1066        if frame:
1067            res = [f"fill = {color2tikz(getattr(sketch, 'frame_back_color'))}"] + res
1068    else:
1069        res = []
1070
1071    return res
1072
1073
1074def get_axis_shading_colors(sketch):
1075    """Returns the shading colors for the axis.
1076
1077    Args:
1078        sketch: The sketch object.
1079
1080    Returns:
1081        str: The shading colors for the axis.
1082    """
1083    def get_color(color, color_key):
1084        if isinstance(color, Color):
1085            res = color2tikz(color)
1086        else:
1087            res = defaults[color_key]
1088
1089        return res
1090
1091    left = get_color(sketch.shade_left_color, "shade_left_color")
1092    right = get_color(sketch.shade_right_color, "shade_right_color")
1093    top = get_color(sketch.shade_top_color, "shade_top_color")
1094    bottom = get_color(sketch.shade_bottom_color, "shade_bottom_color")
1095    middle = get_color(sketch.shade_middle_color, "shade_middle_color")
1096
1097    axis_colors = {
1098        ShadeType.AXIS_BOTTOM_MIDDLE: f"bottom color={bottom}, middle color={middle}",
1099        ShadeType.AXIS_LEFT_MIDDLE: f"left color={left}, middle color={middle}",
1100        ShadeType.AXIS_RIGHT_MIDDLE: f"right color={right}, middle color={middle}",
1101        ShadeType.AXIS_TOP_MIDDLE: f"top color={top}, middle color={middle}",
1102        ShadeType.AXIS_LEFT_RIGHT: f"left color={left}, right color={right}",
1103        ShadeType.AXIS_TOP_BOTTOM: f"top color={top}, bottom color={bottom}",
1104    }
1105
1106    res = axis_colors[sketch.shade_type]
1107    return res
1108
1109
1110def get_bilinear_shading_colors(sketch):
1111    """Returns the shading colors for the bilinear shading.
1112
1113    Args:
1114        sketch: The sketch object.
1115
1116    Returns:
1117        str: The shading colors for the bilinear shading.
1118    """
1119    res = []
1120    if sketch.shade_upper_left_color:
1121        res.append(f"upper left = {color2tikz(sketch.shade_upper_left_color)}")
1122    if sketch.shade_upper_right_color:
1123        res.append(f"upper right = {color2tikz(sketch.shade_upper_right_color)}")
1124    if sketch.shade_lower_left_color:
1125        res.append(f"lower left = {color2tikz(sketch.shade_lower_left_color)}")
1126    if sketch.shade_lower_right_color:
1127        res.append(f"lower right = {color2tikz(sketch.shade_lower_right_color)}")
1128
1129    return ", ".join(res)
1130
1131
1132def get_radial_shading_colors(sketch):
1133    """Returns the shading colors for the radial shading.
1134
1135    Args:
1136        sketch: The sketch object.
1137
1138    Returns:
1139        str: The shading colors for the radial shading.
1140    """
1141    res = []
1142    if sketch.shade_type == ShadeType.RADIAL_INNER:
1143        res.append(f"inner color = {color2tikz(sketch.shade_inner_color)}")
1144    elif sketch.shade_type == ShadeType.RADIAL_OUTER:
1145        res.append(f"outer color = {color2tikz(sketch.shade_outer_color)}")
1146    elif sketch.shade_type == ShadeType.RADIAL_INNER_OUTER:
1147        res.append(f"inner color = {color2tikz(sketch.shade_inner_color)}")
1148        res.append(f"outer color = {color2tikz(sketch.shade_outer_color)}")
1149
1150    return ", ".join(res)
1151
1152
1153axis_shading_types = [
1154    ShadeType.AXIS_BOTTOM_MIDDLE,
1155    ShadeType.AXIS_LEFT_MIDDLE,
1156    ShadeType.AXIS_RIGHT_MIDDLE,
1157    ShadeType.AXIS_TOP_MIDDLE,
1158    ShadeType.AXIS_LEFT_RIGHT,
1159    ShadeType.AXIS_TOP_BOTTOM,
1160]
1161
1162radial_shading_types = [
1163    ShadeType.RADIAL_INNER,
1164    ShadeType.RADIAL_OUTER,
1165    ShadeType.RADIAL_INNER_OUTER,
1166]
1167
1168
1169def get_shading_options(sketch):
1170    """Returns the options for the shading.
1171
1172    Args:
1173        sketch: The sketch object.
1174
1175    Returns:
1176        list: The shading options as a list.
1177    """
1178    shade_type = sketch.shade_type
1179    if shade_type in axis_shading_types:
1180        res = get_axis_shading_colors(sketch)
1181        if sketch.shade_axis_angle:
1182            res += f", shading angle={sketch.shade_axis_angle}"
1183    elif shade_type == ShadeType.BILINEAR:
1184        res = get_bilinear_shading_colors(sketch)
1185    elif shade_type in radial_shading_types:
1186        res = get_radial_shading_colors(sketch)
1187    elif shade_type == ShadeType.BALL:
1188        res = f"ball color = {color2tikz(sketch.shade_ball_color)}"
1189    elif shade_type == ShadeType.COLORWHEEL:
1190        res = "shading=color wheel"
1191    elif shade_type == ShadeType.COLORWHEEL_BLACK:
1192        res = "shading=color wheel black center"
1193    elif shade_type == ShadeType.COLORWHEEL_WHITE:
1194        res = "shading=color wheel white center"
1195
1196    return [res]
1197
1198
1199def get_pattern_options(sketch):
1200    """Returns the options for the patterns.
1201
1202    Args:
1203        sketch: The sketch object.
1204
1205    Returns:
1206        list: The pattern options as a list.
1207    """
1208    pattern_type = sketch.pattern_type
1209    if pattern_type:
1210        distance = sketch.pattern_distance
1211        options = f"pattern={{{pattern_type}[distance={distance}, "
1212        angle = degrees(sketch.pattern_angle)
1213        if angle:
1214            options += f"angle={angle}, "
1215        line_width = sketch.pattern_line_width
1216        if line_width:
1217            options += f"line width={line_width}, "
1218        x_shift = sketch.pattern_x_shift
1219        if x_shift:
1220            options += f"xshift={x_shift}, "
1221        y_shift = sketch.pattern_y_shift
1222        if y_shift:
1223            options += f"yshift={y_shift}, "
1224        if pattern_type in ["Stars", "Dots"]:
1225            radius = sketch.pattern_radius
1226            if radius:
1227                options += f"radius={radius}, "
1228            if pattern_type == "Stars":
1229                points = sketch.pattern_points
1230                if points:
1231                    options += f"points={points}, "
1232        options = options.strip()
1233        if options.endswith(","):
1234            options = options[:-1]
1235        options += "]"
1236        color = sketch.pattern_color
1237        if color and color != sg.black:
1238            options += f", pattern color={color2tikz(color)}, "
1239
1240        options += "}"
1241        res = [options]
1242    else:
1243        res = []
1244
1245    return res
1246
1247
1248def get_marker_options(sketch):
1249    """Returns the options for the markers.
1250
1251    Args:
1252        sketch: The sketch object.
1253
1254    Returns:
1255        list: The marker options as a list.
1256    """
1257    attrib_map = {
1258        # 'marker': 'mark',
1259        "marker_size": "mark size",
1260        "marker_angle": "rotate",
1261        # 'fill_color': 'color',
1262        "marker_color": "color",
1263        "marker_fill": "fill",
1264        "marker_opacity": "opacity",
1265        "marker_repeat": "mark repeat",
1266        "marker_phase": "mark phase",
1267        "marker_tension": "tension",
1268        "marker_line_width": "line width",
1269        "marker_line_style": "style",
1270        # 'line_color': 'line color',
1271    }
1272    # if mark_stroke is false make line color same as fill color
1273    if sketch.draw_markers:
1274        res = sg_to_tikz(sketch, marker_style_map.keys(), attrib_map)
1275    else:
1276        res = []
1277
1278    return res
1279
1280
1281def draw_shape_sketch_with_indices(sketch, ind):
1282    """Draws a shape sketch with circle markers with index numbers in them.
1283
1284    Args:
1285        sketch: The shape sketch object.
1286        ind: The index.
1287
1288    Returns:
1289        str: The TikZ code for the shape sketch with indices.
1290    """
1291    begin_scope = get_begin_scope(ind)
1292    body = get_draw(sketch)
1293    if body:
1294        options = get_line_style_options(sketch)
1295        if sketch.fill and sketch.closed:
1296            options += get_fill_style_options(sketch)
1297        if sketch.smooth:
1298            if sketch.closed:
1299                options += ["smooth cycle"]
1300            else:
1301                options += ["smooth"]
1302        options = ", ".join(options)
1303        body += f"[{options}]"
1304    else:
1305        body = ""
1306    vertices = sketch.vertices
1307    vertices = [str(x) for x in vertices]
1308    str_lines = [vertices[0] + "node{0}"]
1309    n = len(vertices)
1310    for i, vertice in enumerate(vertices[1:]):
1311        if (i + 1) % 6 == 0:
1312            if i == n - 1:
1313                str_lines.append(f" -- {vertice} node{{{i+1}}}\n")
1314            else:
1315                str_lines.append(f"\n\t-- {vertice} node{{{i+1}}}")
1316        else:
1317            str_lines.append(f"-- {vertice} node{{{i+1}}}")
1318    if body:
1319        if sketch.closed:
1320            str_lines.append(" -- cycle;\n")
1321        str_lines.append(";\n")
1322    end_scope = get_end_scope()
1323
1324    return begin_scope + body + "".join(str_lines) + end_scope
1325
1326
1327def draw_shape_sketch_with_markers(sketch):
1328    """Draws a shape sketch with markers.
1329
1330    Args:
1331        sketch: The shape sketch object.
1332
1333    Returns:
1334        str: The TikZ code for the shape sketch with markers.
1335    """
1336    # begin_scope = get_begin_scope()
1337    body = get_draw(sketch)
1338    if body:
1339        options = get_line_style_options(sketch)
1340        if sketch.fill and sketch.closed:
1341            options += get_fill_style_options(sketch)
1342        if sketch.smooth and sketch.closed:
1343            options += ["smooth cycle"]
1344        elif sketch.smooth:
1345            options += ["smooth"]
1346        options = ", ".join(options)
1347        if options:
1348            body += f"[{options}]"
1349    else:
1350        body = ""
1351
1352    if sketch.draw_markers:
1353        marker_options = ", ".join(get_marker_options(sketch))
1354    else:
1355        marker_options = ""
1356
1357    vertices = [str(x) for x in sketch.vertices]
1358
1359    str_lines = [vertices[0]]
1360    for i, vertice in enumerate(vertices[1:]):
1361        if (i + 1) % 6 == 0:
1362            str_lines.append(f"\n\t{vertice} ")
1363        else:
1364            str_lines.append(f" {vertice} ")
1365    coordinates = "".join(str_lines)
1366
1367    marker = get_enum_value(MarkerType, sketch.marker_type)
1368    # marker = sketch.marker_type.value
1369    if sketch.markers_only:
1370        markers_only = "only marks ,"
1371    else:
1372        markers_only = ""
1373    if sketch.draw_markers and marker_options:
1374        body += (
1375            f" plot[mark = {marker}, {markers_only}mark options = {{{marker_options}}}] "
1376            f"\ncoordinates {{{coordinates}}};\n"
1377        )
1378    elif sketch.draw_markers:
1379        body += (
1380            f" plot[mark = {marker}, {markers_only}] coordinates {{{coordinates}}};\n"
1381        )
1382    else:
1383        body += f" plot[tension=.5] coordinates {{{coordinates}}};\n"
1384
1385    return body
1386
1387
1388def get_begin_scope(ind=None):
1389    """Returns \begin{scope}[every node/.append style=nodestyle{ind}].
1390
1391    Args:
1392        ind: Optional index for the scope.
1393
1394    Returns:
1395        str: The begin scope string.
1396    """
1397    if ind is None:
1398        res = "\\begin{scope}[]\n"
1399    else:
1400        res = f"\\begin{{scope}}[every node/.append style=nodestyle{ind}]\n"
1401
1402    return res
1403
1404
1405def get_end_scope():
1406    """Returns \\end{scope}.
1407
1408    Returns:
1409        str: The end scope string.
1410    """
1411    return "\\end{scope}\n"
1412
1413def draw_pattern_sketch(sketch):
1414    """Draws a pattern sketch.
1415
1416    Args:
1417        sketch: The pattern sketch object.
1418
1419    Returns:
1420        str: The TikZ code for the pattern sketch.
1421    """
1422    begin_scope = "\\begin{scope}"
1423
1424    options = []
1425
1426    if sketch.back_style == BackStyle.PATTERN and sketch.fill and sketch.closed:
1427        options += get_pattern_options(sketch)
1428    if sketch.stroke:
1429        options += get_line_style_options(sketch)
1430    if sketch.closed and sketch.fill:
1431        options += get_fill_style_options(sketch)
1432    if sketch.smooth:
1433        options += ["smooth"]
1434    if sketch.back_style == BackStyle.SHADING and sketch.fill and sketch.closed:
1435        options += get_shading_options(sketch)
1436    options = ", ".join(options)
1437    if options:
1438        begin_scope += f"[{options}]\n"
1439    end_scope = get_end_scope()
1440
1441    pattern = sketch.pattern
1442    draw = get_draw(sketch)
1443    if not draw:
1444        return ""
1445    all_vertices = sketch.kernel_vertices @ sketch.all_matrices
1446    vertices_list = np.hsplit(all_vertices, sketch.count)
1447    shapes = []
1448    for vertices in vertices_list:
1449        vertices @= sketch.xform_matrix
1450        vertices = [tuple(vert) for vert in vertices[:,:2].tolist()]
1451        n = len(vertices)
1452        str_lines = [f"{vertices[0]}"]
1453        for i, vertice in enumerate(vertices[1:]):
1454            if (i + 1) % 8 == 0:
1455                if i == n - 1:
1456                    str_lines.append(f"-- {vertice} \n")
1457                else:
1458                    str_lines.append(f"\n\t-- {vertice} ")
1459            else:
1460                str_lines.append(f"-- {vertice} ")
1461        if sketch.closed:
1462            str_lines.append("-- cycle;\n")
1463        else:
1464            str_lines.append(";\n")
1465        shapes.append(draw + "".join(str_lines))
1466
1467
1468    return begin_scope + f"[{options}]\n" +  "\n".join(shapes) + end_scope
1469
1470
1471def draw_sketch(sketch):
1472    """Draws a plain shape sketch.
1473
1474    Args:
1475        sketch: The shape sketch object.
1476
1477    Returns:
1478        str: The TikZ code for the plain shape sketch.
1479    """
1480    res = get_draw(sketch)
1481    if not res:
1482        return ""
1483    options = []
1484
1485    if sketch.back_style == BackStyle.PATTERN and sketch.fill and sketch.closed:
1486        options += get_pattern_options(sketch)
1487    if sketch.stroke:
1488        options += get_line_style_options(sketch)
1489    if sketch.closed and sketch.fill:
1490        options += get_fill_style_options(sketch)
1491    if sketch.smooth:
1492        options += ["smooth"]
1493    if sketch.back_style == BackStyle.SHADING and sketch.fill and sketch.closed:
1494        options += get_shading_options(sketch)
1495    options = ", ".join(options)
1496    if options:
1497        res += f"[{options}]"
1498    vertices = sketch.vertices
1499    n = len(vertices)
1500    str_lines = [f"{vertices[0]}"]
1501    for i, vertice in enumerate(vertices[1:]):
1502        if (i + 1) % 8 == 0:
1503            if i == n - 1:
1504                str_lines.append(f"-- {vertice} \n")
1505            else:
1506                str_lines.append(f"\n\t-- {vertice} ")
1507        else:
1508            str_lines.append(f"-- {vertice} ")
1509    if sketch.closed:
1510        str_lines.append("-- cycle;\n")
1511    else:
1512        str_lines.append(";\n")
1513    if res:
1514        res += "".join(str_lines)
1515    else:
1516        res = "".join(str_lines)
1517    return res
1518
1519
1520def draw_tex_sketch(sketch):
1521    """Draws a TeX sketch.
1522
1523    Args:
1524        sketch: The TeX sketch object.
1525
1526    Returns:
1527        str: The TeX code for the TeX sketch.
1528    """
1529
1530    return sketch.code
1531
1532def draw_shape_sketch(sketch, ind=None):
1533    """Draws a shape sketch.
1534
1535    Args:
1536        sketch: The shape sketch object.
1537        ind: Optional index for the shape sketch.
1538
1539    Returns:
1540        str: The TikZ code for the shape sketch.
1541    """
1542    d_subtype_draw = {
1543        sg.Types.ARC_SKETCH: draw_arc_sketch,
1544        sg.Types.BEZIER_SKETCH: draw_bezier_sketch,
1545        sg.Types.CIRCLE_SKETCH: draw_circle_sketch,
1546        sg.Types.ELLIPSE_SKETCH: draw_ellipse_sketch,
1547        sg.Types.LINE_SKETCH: draw_line_sketch,
1548    }
1549    if sketch.subtype in d_subtype_draw:
1550        res = d_subtype_draw[sketch.subtype](sketch)
1551    elif sketch.draw_markers and sketch.marker_type == MarkerType.INDICES:
1552        res = draw_shape_sketch_with_indices(sketch, ind)
1553    elif sketch.draw_markers or sketch.smooth:
1554        res = draw_shape_sketch_with_markers(sketch)
1555    else:
1556        res = draw_sketch(sketch)
1557
1558    return res
1559
1560def draw_line_sketch(sketch):
1561    """Draws a line sketch.
1562
1563    Args:
1564        sketch: The line sketch object.
1565
1566    Returns:
1567        str: The TikZ code for the line sketch.
1568    """
1569    begin_scope = get_begin_scope()
1570    res = "\\draw"
1571    exceptions = ["draw_fillets", "fillet_radius", "line_join", "line_miter_limit"]
1572    options = get_line_style_options(sketch, exceptions=exceptions)
1573
1574    start = sketch.vertices[0]
1575    end = sketch.vertices[1]
1576    options = ", ".join(options)
1577    res += f"[{options}]"
1578    res += f" {start[:2]} -- {end[:2]};\n"
1579    end_scope = get_end_scope()
1580
1581    return begin_scope + res + end_scope
1582
1583
1584def draw_circle_sketch(sketch):
1585    """Draws a circle sketch.
1586
1587    Args:
1588        sketch: The circle sketch object.
1589
1590    Returns:
1591        str: The TikZ code for the circle sketch.
1592    """
1593    begin_scope = get_begin_scope()
1594    res = get_draw(sketch)
1595    if not res:
1596        return ""
1597    options = get_line_style_options(sketch)
1598    fill_options = get_fill_style_options(sketch)
1599    options += fill_options
1600    if sketch.smooth:
1601        options += ["smooth"]
1602    options = ", ".join(options)
1603    if options:
1604        res += f"[{options}]"
1605    x, y = sketch.center[:2]
1606    res += f"({x}, {y}) circle ({sketch.radius});\n"
1607    end_scope = get_end_scope()
1608
1609    return begin_scope + res + end_scope
1610
1611
1612def draw_rect_sketch(sketch):
1613    """Draws a rectangle sketch.
1614
1615    Args:
1616        sketch: The rectangle sketch object.
1617
1618    Returns:
1619        str: The TikZ code for the rectangle sketch.
1620    """
1621    begin_scope = get_begin_scope()
1622    res = get_draw(sketch)
1623    if not res:
1624        return ""
1625    options = get_line_style_options(sketch)
1626    fill_options = get_fill_style_options(sketch)
1627    options += fill_options
1628    if sketch.smooth:
1629        options += ["smooth"]
1630    options = ", ".join(options)
1631    res += f"[{options}]"
1632    x, y = sketch.center[:2]
1633    width, height = sketch.width, sketch.height
1634    res += f"({x}, {y}) rectangle ({width}, {height});\n"
1635    end_scope = get_end_scope()
1636
1637    return begin_scope + res + end_scope
1638
1639def draw_ellipse_sketch(sketch):
1640    """Draws an ellipse sketch.
1641
1642    Args:
1643        sketch: The ellipse sketch object.
1644
1645    Returns:
1646        str: The TikZ code for the ellipse sketch.
1647    """
1648    begin_scope = get_begin_scope()
1649    res = get_draw(sketch)
1650    if not res:
1651        return ""
1652    options = get_line_style_options(sketch)
1653    fill_options = get_fill_style_options(sketch)
1654    options += fill_options
1655    if sketch.smooth:
1656        options += ["smooth"]
1657    angle = degrees(sketch.angle)
1658    x, y = sketch.center[:2]
1659    if angle:
1660        options += [f"rotate around= {{{angle}:({x},{y})}}"]
1661    options = ", ".join(options)
1662    res += f"[{options}]"
1663    a = sketch.x_radius
1664    b = sketch.y_radius
1665
1666    res += f"({x}, {y}) ellipse ({a} and {b});\n"
1667    end_scope = get_end_scope()
1668
1669    return begin_scope + res + end_scope
1670
1671
1672def draw_arc_sketch(sketch):
1673    """Draws an arc sketch.
1674
1675    Args:
1676        sketch: The arc sketch object.
1677
1678    Returns:
1679        str: The TikZ code for the arc sketch.
1680    """
1681    res = get_draw(sketch)
1682    if not res:
1683        return ""
1684    if sketch.closed:
1685        options = ["smooth cycle"]
1686    else:
1687        options = ['smooth']
1688
1689    if sketch.back_style == BackStyle.PATTERN and sketch.fill and sketch.closed:
1690        options += get_pattern_options(sketch)
1691    if sketch.stroke:
1692        options += get_line_style_options(sketch)
1693    if sketch.closed and sketch.fill:
1694        options += get_fill_style_options(sketch)
1695
1696    if sketch.back_style == BackStyle.SHADING and sketch.fill and sketch.closed:
1697        options += get_shading_options(sketch)
1698    options = ", ".join(options)
1699    if options:
1700        res += f"[{options}] plot[tension=.8] coordinates" + "{"
1701    vertices = [round_point(v) for v in sketch.vertices]
1702    n = len(vertices)
1703    str_lines = [f"{vertices[0]}"]
1704    for i, vertice in enumerate(vertices[1:]):
1705        if (i + 1) % 8 == 0:
1706            if i == n - 1:
1707                str_lines.append(f" {vertice} \n")
1708            else:
1709                str_lines.append(f"\n\t {vertice} ")
1710        else:
1711            str_lines.append(f" {vertice} ")
1712    if sketch.closed:
1713        str_lines.append(" cycle;\n")
1714    else:
1715        str_lines.append("};\n")
1716    if res:
1717        res += "".join(str_lines)
1718    else:
1719        res = "".join(str_lines)
1720    return res
1721
1722def draw_bezier_sketch(sketch):
1723    """Draws a Bezier curve sketch.
1724
1725    Args:
1726        sketch: The Bezier curve sketch object.
1727
1728    Returns:
1729        str: The TikZ code for the Bezier curve sketch.
1730    """
1731    begin_scope = get_begin_scope()
1732    res = get_draw(sketch)
1733    if not res:
1734        return ""
1735    options = get_line_style_options(sketch)
1736    options = ", ".join(options)
1737    res += f"[{options}]"
1738    p1, cp1, cp2, p2 = sketch.control_points
1739    x1, y1 = p1[:2]
1740    x2, y2 = cp1[:2]
1741    x3, y3 = cp2[:2]
1742    x4, y4 = p2[:2]
1743    res += f" ({x1}, {y1}) .. controls ({x2}, {y2}) and ({x3}, {y3}) .. ({x4}, {y4});\n"
1744    end_scope = get_end_scope()
1745
1746    return begin_scope + res + end_scope
1747
1748
1749def draw_line(line):
1750    """Tikz code for a line.
1751
1752    Args:
1753        line: The line object.
1754
1755    Returns:
1756        str: The TikZ code for the line.
1757    """
1758    p1 = line.start[:2]
1759    p2 = line.end[:2]
1760    options = []
1761    if line.line_width is not None:
1762        options.append(line.line_width)
1763    if line.color is not None:
1764        color = color2tikz(line.color)
1765        options.append(color)
1766    if line.dash_array is not None:
1767        options.append(line.dash_array)
1768    # options = [line.width, line.color, line.dash_array, line.cap, line.join]
1769    if line.line_width == 0:
1770        res = f"\\path[{', '.join(options)}] {p1} -- {p2};\n"
1771    else:
1772        res = f"\\draw[{', '.join(options)}] {p1} -- {p2};\n"
1773
1774    return res
1775
1776
1777def is_stroked(shape: Shape) -> bool:
1778    """Returns True if the shape is stroked.
1779
1780    Args:
1781        shape (Shape): The shape object.
1782
1783    Returns:
1784        bool: True if the shape is stroked, False otherwise.
1785    """
1786    return shape.stroke and shape.line_color is not None and shape.line_width > 0
1787
1788
1789d_sketch_draw = {
1790    sg.Types.SHAPE: draw_shape_sketch,
1791    sg.Types.TAG_SKETCH: draw_tag_sketch,
1792    sg.Types.LACESKETCH: draw_lace_sketch,
1793    sg.Types.LINE: draw_line_sketch,
1794    sg.Types.CIRCLE: draw_circle_sketch,
1795    sg.Types.ELLIPSE: draw_shape_sketch,
1796    sg.Types.ARC: draw_arc_sketch,
1797    sg.Types.BATCH: draw_batch_sketch,
1798}