refactor hpgl2 add-on

Author: mozman

src/ezdxf/addons/hpgl2/api.py

@@ -5,16 +5,16 @@
 from ezdxf.document import Drawing
 from ezdxf import zoom, transform
 from ezdxf.math import Matrix44
-from .tokenizer import parse
+from .tokenizer import hpgl2_commands
 from .plotter import Plotter
 from .interpreter import Interpreter
-from .backend import BoundingBoxDetector
+from .backend import Recorder
 from .dxf_backend import DXFBackend, ColorMode
 from .svg_backend import SVGBackend
 from .compiler import build
 
 
-def plot_to_dxf(
+def to_dxf(
     b: bytes,
     scale: float = 1.0,
     *,
@@ -23,20 +23,14 @@ def plot_to_dxf(
 ) -> Drawing:
     doc = ezdxf.new()
     msp = doc.modelspace()
-    commands = parse(b)
     plotter = Plotter(
         DXFBackend(
             msp,
             color_mode=color_mode,
             map_black_rgb_to_white_rgb=map_black_rgb_to_white_rgb,
         )
     )
-    interpreter = Interpreter(plotter)
-    interpreter.run(commands)
-    if interpreter.not_implemented_commands:
-        print(
-            f"not implemented commands: {sorted(interpreter.not_implemented_commands)}"
-        )
+    Interpreter(plotter).run(hpgl2_commands(b))
     if plotter.bbox.has_data:  # non-empty page
         _scale_and_zoom(msp, scale, plotter.bbox)
     return doc
@@ -53,24 +47,15 @@ def _scale_and_zoom(layout, scale, bbox):
     zoom.window(layout, extmin, extmax)
 
 
-PROLOG = (
-    '<?xml version="1.0" encoding="UTF-8"?>\n'
-    '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n'
-)
-
-
-def plot_to_svg(b: bytes) -> str:
-    # 1st pass detect extents
-    detector = BoundingBoxDetector()
-    plotter = Plotter(detector)
-    commands = parse(b)
-    interpreter = Interpreter(plotter)
-    interpreter.run(commands)
-    if not detector.bbox.has_data:
+def to_svg(b: bytes) -> str:
+    # 1st pass records the plotting commands and detects the bounding box
+    recorder = Recorder()
+    plotter = Plotter(recorder)
+    Interpreter(plotter).run(hpgl2_commands(b))
+    if not plotter.bbox.has_data:
         return ""
-    # 2nd pass plot SVG
-    svg_backend = SVGBackend(detector.bbox)
-    plotter = Plotter(svg_backend)
-    interpreter = Interpreter(plotter)
-    interpreter.run(commands)
-    return PROLOG + svg_backend.get_string()
+
+    # 2nd pass replays the plotting commands to plot the SVG
+    svg_backend = SVGBackend(plotter.bbox)
+    recorder.replay(svg_backend)
+    return svg_backend.get_string()

src/ezdxf/addons/hpgl2/backend.py

@@ -1,8 +1,10 @@
 #  Copyright (c) 2023, Manfred Moitzi
 #  License: MIT License
 from __future__ import annotations
-from typing import Sequence
+from typing import Sequence, NamedTuple, Any
 import abc
+import enum
+
 from .deps import Vec2, Path, Bezier4P, BoundingBox2d
 from .properties import Properties
 
@@ -16,14 +18,6 @@
 
 
 class Backend(abc.ABC):
-    def draw_cubic_bezier(
-        self, properties: Properties, start: Vec2, ctrl1: Vec2, ctrl2: Vec2, end: Vec2
-    ) -> None:
-        # input coordinates are page coordinates
-        curve = Bezier4P([start, ctrl1, ctrl2, end])
-        # 10 plu = 0.25 mm
-        self.draw_polyline(properties, list(curve.flattening(distance=10)))
-
     @abc.abstractmethod
     def draw_polyline(self, properties: Properties, points: Sequence[Vec2]) -> None:
         # input coordinates are page coordinates
@@ -44,27 +38,48 @@ def draw_outline_polygon_buffer(
         # input coordinates are page coordinates
         ...
 
-class BoundingBoxDetector(Backend):
-    def __init__(self, max_distance=10):
-        self.max_distance = max_distance
-        self.bbox = BoundingBox2d()
+class RecordType(enum.Enum):
+    POLYLINE = enum.auto()
+    FILLED_POLYGON = enum.auto()
+    OUTLINE_POLYGON = enum.auto()
+
+class DataRecord(NamedTuple):
+    type: RecordType
+    property_hash: int
+    args: Any
+
+class Recorder(Backend):
+    def __init__(self) -> None:
+        self.records: list[DataRecord] = []
+        self.properties: dict[int, Properties] = {}
 
     def draw_polyline(self, properties: Properties, points: Sequence[Vec2]) -> None:
-        # input coordinates are page coordinates
-        # argument <points> can be zero, one, two or more points.
-        self.bbox.extend(points)
+        self.store(RecordType.POLYLINE, properties, tuple(points))
+
 
     def draw_filled_polygon_buffer(
         self, properties: Properties, paths: Sequence[Path], fill_method: int
     ) -> None:
-        # input coordinates are page coordinates
-        for p in paths:
-            self.bbox.extend(p.flattening(distance=self.max_distance))
+        self.store(RecordType.FILLED_POLYGON, properties, tuple(paths), fill_method)
 
     def draw_outline_polygon_buffer(
         self, properties: Properties, paths: Sequence[Path]
     ) -> None:
-        # input coordinates are page coordinates
-        for p in paths:
-            self.bbox.extend(p.flattening(distance=self.max_distance))
+        self.store(RecordType.OUTLINE_POLYGON, properties, tuple(paths))
+
+    def store(self, record_type: RecordType, properties: Properties, *args) -> None:
+        prop_hash = properties.hash()
+        if prop_hash not in self.properties:
+            self.properties[prop_hash] = properties.copy()
+        self.records.append(DataRecord(record_type, prop_hash, args))
 
+    def replay(self, backend: Backend) -> None:
+        properties = Properties()
+        draw = {
+            RecordType.POLYLINE: backend.draw_polyline,
+            RecordType.FILLED_POLYGON: backend.draw_filled_polygon_buffer,
+            RecordType.OUTLINE_POLYGON: backend.draw_outline_polygon_buffer,
+        }
+        for record in self.records:
+            properties = self.properties.get(record.property_hash, properties)
+            draw[record.type](properties, *record.args)  # type: ignore

src/ezdxf/addons/hpgl2/plotter.py

@@ -4,7 +4,15 @@
 from typing import Sequence, Iterator, Iterable
 import math
 
-from .deps import Vec2, Path, NULLVEC2, ConstructionCircle, BoundingBox2d, path_bbox
+from .deps import (
+    Vec2,
+    Path,
+    NULLVEC2,
+    ConstructionCircle,
+    BoundingBox2d,
+    path_bbox,
+    Bezier4P,
+)
 from .properties import RGB, Properties
 from .backend import Backend
 from .polygon_buffer import PolygonBuffer
@@ -57,7 +65,6 @@ def reset(self) -> None:
 
     def setup_page(self, size_x: int, size_y: int):
         self.page = Page(size_x, size_y)
-        self.properties.set_page_size(size_x, size_y)
 
     def set_scaling_points(self, p1: Vec2, p2: Vec2) -> None:
         self.page.set_scaling_points(p1, p2)
@@ -272,8 +279,10 @@ def plot_abs_cubic_bezier(self, ctrl1: Vec2, ctrl2: Vec2, end: Vec2):
             ctrl1, ctrl2, end = self.page.page_points((ctrl1, ctrl2, end))
             # draw cubic bezier curve in absolute page coordinates:
             self.update_bbox((ctrl1, ctrl2, end))
-            self.backend.draw_cubic_bezier(
-                self.properties, current_page_location, ctrl1, ctrl2, end
+            curve = Bezier4P([current_page_location, ctrl1, ctrl2, end])
+            # distance of 10 plu is 0.25 mm
+            self.backend.draw_polyline(
+                self.properties, list(curve.flattening(distance=10))
             )
 
     def plot_rel_cubic_bezier(self, ctrl1: Vec2, ctrl2: Vec2, end: Vec2):

src/ezdxf/addons/hpgl2/properties.py

@@ -4,6 +4,7 @@
 from typing import NamedTuple
 import dataclasses
 import enum
+import copy
 from .deps import NULLVEC2
 
 
@@ -32,50 +33,62 @@ class Pen:
 
 
 class Properties:
-    DEFAULT_PEN = Pen(1, 0.35, RGB(0, 0, 0))
+    DEFAULT_PEN = Pen(1, 0.35, RGB_NONE)
 
     def __init__(self) -> None:
-        self.max_pen_count: int = 2
+        # hashed content
         self.pen_index: int = 1
         self.pen_color = RGB_NONE
         self.pen_width: float = 0.35
-        self.pen_table: dict[int, Pen] = {}
         self.fill_type = FillType.SOLID
         self.fill_hatch_line_angle: float = 0.0  # in degrees
         self.fill_hatch_line_spacing: float = 40.0  # in plotter units
         self.fill_shading_density: float = 100.0
-        self.page_width: int = 0  # in plotter units
-        self.page_height: int = 0  # in plotter units
         self.clipping_window = (NULLVEC2, NULLVEC2)  # in plotter units
+        # not hashed content
+        self.max_pen_count: int = 2
+        self.pen_table: dict[int, Pen] = {}
         self.reset()
 
-    def has_clipping_window(self) -> bool:
-        return self.clipping_window[0] is not self.clipping_window[1]
+    def hash(self) -> int:
+        return hash(
+            (
+                self.pen_index,
+                self.pen_color,
+                self.pen_width,
+                self.fill_type,
+                self.fill_hatch_line_angle,
+                self.fill_hatch_line_spacing,
+                self.fill_shading_density,
+                self.clipping_window,
+            )
+        )
+
+    def copy(self) -> Properties:
+        # the pen table is shared across all copies of Properties
+        return copy.copy(self)
 
     def reset(self) -> None:
         self.max_pen_count = 2
-        self.pen_index = 1
-        self.pen_color = RGB(0, 0, 0)
-        self.pen_width = 0.35  # in mm
+        self.pen_index = self.DEFAULT_PEN.index
+        self.pen_color = self.DEFAULT_PEN.color
+        self.pen_width = self.DEFAULT_PEN.width
         self.pen_table = {}
         self.fill_type = FillType.SOLID
         self.fill_hatch_line_angle = 0.0
         self.fill_hatch_line_spacing = 40.0
         self.fill_shading_density = 1.0
         self.reset_clipping_window()
-        # do not reset the page size
+
+    def has_clipping_window(self) -> bool:
+        return self.clipping_window[0] is not self.clipping_window[1]
 
     def reset_clipping_window(self) -> None:
         self.clipping_window = (NULLVEC2, NULLVEC2)
 
     def get_pen(self, index: int) -> Pen:
         return self.pen_table.get(index, self.DEFAULT_PEN)
 
-    def set_page_size(self, width: int, height: int) -> None:
-        # in plotter units
-        self.page_width = int(width)
-        self.page_height = int(height)
-
     def set_max_pen_count(self, count: int) -> None:
         self.max_pen_count = count