improve hpgl2 add-on and add plt2dxf and plt2svg commands

add mirror modes to hpgl2 converter commands
add rotation support to hpgl2.to_svg() function
add rotation support to hpgl2.to_dxf() function
remove all unsupported commands
improve hpgl2 parser
add setup of "Layout0" to dxf_backend
add plt2dxf command to ezdxf launcher
add plt2svg command to ezdxf launcher
profile new fast_bbox() function
move fill_method to Properties

Author: mozman

NEWS.md

@@ -10,8 +10,10 @@ Version 1.0.4 - dev
 - BUGFIX: invalid bulge to Bezier curve conversion for bulge values >= 1
 - BUGFIX: [#855](https://github.com/mozman/ezdxf/issues/855)
   scale `MTEXT/MLEADER` inline commands "absolute text height" at transformation
-- PREVIEW: `ezdxf.addons.hpgl2` add-on to convert HPGL/2 plot files to DXF,  
+- PREVIEW: `ezdxf.addons.hpgl2` add-on to convert HPGL/2 plot files to DXF or SVG,  
   final release in v1.1
+- PREVIEW: `ezdxf plt2dxf` command to convert HPGL/2 plot files to DXF, final release in v1.1
+- PREVIEW: `ezdxf plt2svg` command to convert HPGL/2 plot files to SVG, final release in v1.1
 
 Version 1.0.3 - 2023-03-26
 --------------------------

profiling/path_bbox.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2021, Manfred Moitzi
+# License: MIT License
+import time
+import math
+from ezdxf.math import BoundingBox, Vec3
+from ezdxf.render.forms import circle
+import ezdxf.path
+
+LARGE_PATH = ezdxf.path.from_vertices(circle(100, radius=10))
+
+def current_fast_bbox():
+    ezdxf.path.bbox((LARGE_PATH, ), fast=True)
+
+def current_precise_bbox():
+    ezdxf.path.bbox((LARGE_PATH, ), fast=False)
+
+def new_fast_bbox():
+    fast_bbox(LARGE_PATH)
+
+
+def fast_bbox(path) -> BoundingBox:
+    # it's much slower!
+    bbox = BoundingBox()
+    if len(path) == 0:
+        return bbox
+    min_x = math.inf
+    min_y = math.inf
+    min_z = math.inf
+    max_x = -math.inf
+    max_y = -math.inf
+    max_z = -math.inf
+    for x, y, z in path.control_vertices():
+        min_x = min(min_x, x)
+        min_y = min(min_y, y)
+        min_z = min(min_z, z)
+        max_x = max(max_x, x)
+        max_y = max(max_y, y)
+        max_z = max(max_z, z)
+    bbox.extend([Vec3(min_x, min_y, min_z), Vec3(max_x, max_y, max_z)])
+    return bbox
+
+
+def profile(text, func, runs):
+    t0 = time.perf_counter()
+    for _ in range(runs):
+        func()
+    t1 = time.perf_counter()
+    t = t1 - t0
+    print(f"{text} {t:.3f}s")
+
+
+RUNS = 10_000
+
+print(f"Profiling bounding box calculation:")
+profile(f"current_precise_bbox() {RUNS}:", current_precise_bbox, RUNS)
+profile(f"current_fast_bbox() {RUNS}:", current_fast_bbox, RUNS)
+profile(f"new_fast_bbox() {RUNS}:", new_fast_bbox, RUNS)

src/ezdxf/addons/hpgl2/api.py

@@ -4,7 +4,8 @@
 import ezdxf
 from ezdxf.document import Drawing
 from ezdxf import zoom, transform
-from ezdxf.math import Matrix44
+from ezdxf.math import Matrix44, BoundingBox
+
 from .tokenizer import hpgl2_commands
 from .plotter import Plotter
 from .interpreter import Interpreter
@@ -18,9 +19,14 @@ def to_dxf(
     b: bytes,
     scale: float = 1.0,
     *,
+    rotation: int=0,
+    flip_horizontal=False,
+    flip_vertical=False,
     color_mode=ColorMode.RGB,
     map_black_rgb_to_white_rgb=False,
 ) -> Drawing:
+    if rotation not in (0, 90, 180, 270):
+        raise ValueError("invalid rotation angle: should be 0, 90, 180, or 270")
     doc = ezdxf.new()
     msp = doc.modelspace()
     plotter = Plotter(
@@ -30,9 +36,16 @@ def to_dxf(
             map_black_rgb_to_white_rgb=map_black_rgb_to_white_rgb,
         )
     )
-    Interpreter(plotter).run(hpgl2_commands(b))
+    plotter.set_page_rotation(rotation)
+    interpreter = Interpreter(plotter)
+    if flip_vertical or flip_horizontal:
+        plotter.set_page_flip(vertical=flip_vertical, horizontal=flip_horizontal)
+        # disable embedded scaling commands
+        interpreter.disable_commands(["SC", "IP", "IR"])
+    interpreter.run(hpgl2_commands(b))
     if plotter.bbox.has_data:  # non-empty page
-        _scale_and_zoom(msp, scale, plotter.bbox)
+        bbox = _scale_and_zoom(msp, scale, plotter.bbox)
+        _reset_doc(doc, bbox)
     return doc
 
 
@@ -45,13 +58,35 @@ def _scale_and_zoom(layout, scale, bbox):
         extmin = m.transform(extmin)
         extmax = m.transform(extmax)
     zoom.window(layout, extmin, extmax)
+    return BoundingBox([extmin, extmax])
+
+def _reset_doc(doc, bbox):
+    doc.header["$EXTMIN"] = bbox.extmin
+    doc.header["$EXTMAX"] = bbox.extmax
+
+    psp_size = bbox.size / 40.0  # plu to mm
+    psp_center = psp_size * 0.5
+    psp = doc.paperspace()
+    psp.page_setup(size=(psp_size.x, psp_size.y), margins=(0, 0, 0, 0), units="mm")
+    psp.add_viewport(
+        center=psp_center,
+        size=(psp_size.x, psp_size.y),
+        view_center_point=bbox.center,
+        view_height=bbox.size.y,
+    )
 
 
-def to_svg(b: bytes) -> str:
+def to_svg(b: bytes, *, rotation: int=0, flip_horizontal=False, flip_vertical=False) -> str:
     # 1st pass records the plotting commands and detects the bounding box
     recorder = Recorder()
     plotter = Plotter(recorder)
-    Interpreter(plotter).run(hpgl2_commands(b))
+    plotter.set_page_rotation(rotation)
+    interpreter = Interpreter(plotter)
+    if flip_vertical or flip_horizontal:
+        plotter.set_page_flip(vertical=flip_vertical, horizontal=flip_horizontal)
+        # disable embedded scaling commands
+        interpreter.disable_commands(["SC", "IP", "IR"])
+    interpreter.run(hpgl2_commands(b))
     if not plotter.bbox.has_data:
         return ""
 

src/ezdxf/addons/hpgl2/backend.py

@@ -5,7 +5,7 @@
 import abc
 import enum
 
-from .deps import Vec2, Path, Bezier4P, BoundingBox2d
+from .deps import Vec2, Path
 from .properties import Properties
 
 # Page coordinates are always plot units:
@@ -26,7 +26,7 @@ def draw_polyline(self, properties: Properties, points: Sequence[Vec2]) -> None:
 
     @abc.abstractmethod
     def draw_filled_polygon_buffer(
-        self, properties: Properties, paths: Sequence[Path], fill_method: int
+        self, properties: Properties, paths: Sequence[Path]
     ) -> None:
         # input coordinates are page coordinates
         ...
@@ -38,16 +38,19 @@ def draw_outline_polygon_buffer(
         # input coordinates are page coordinates
         ...
 
+
 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] = []
@@ -56,11 +59,10 @@ def __init__(self) -> None:
     def draw_polyline(self, properties: Properties, points: Sequence[Vec2]) -> None:
         self.store(RecordType.POLYLINE, properties, tuple(points))
 
-
     def draw_filled_polygon_buffer(
-        self, properties: Properties, paths: Sequence[Path], fill_method: int
+        self, properties: Properties, paths: Sequence[Path]
     ) -> None:
-        self.store(RecordType.FILLED_POLYGON, properties, tuple(paths), fill_method)
+        self.store(RecordType.FILLED_POLYGON, properties, tuple(paths))
 
     def draw_outline_polygon_buffer(
         self, properties: Properties, paths: Sequence[Path]
@@ -74,12 +76,13 @@ def store(self, record_type: RecordType, properties: Properties, *args) -> None:
         self.records.append(DataRecord(record_type, prop_hash, args))
 
     def replay(self, backend: Backend) -> None:
-        properties = Properties()
+        current_props = Properties()
+        props = self.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
+            current_props = props.get(record.property_hash, current_props)
+            draw[record.type](current_props, *record.args)  # type: ignore

src/ezdxf/addons/hpgl2/dxf_backend.py

@@ -63,7 +63,7 @@ def draw_polyline(self, properties: Properties, points: Sequence[Vec2]) -> None:
             self.layout.add_point(points[0], dxfattribs=attribs)
 
     def draw_filled_polygon_buffer(
-        self, properties: Properties, paths: Sequence[Path], fill_method: int
+        self, properties: Properties, paths: Sequence[Path]
     ) -> None:
         attribs = self.make_dxf_attribs(properties)
         # max sagitta distance of 10 plu = 0.25 mm
@@ -73,6 +73,8 @@ def draw_filled_polygon_buffer(
         for hatch in hatches:
             assert isinstance(hatch, Hatch)
             rgb: Optional[RGB] = properties.pen_color
+            if self.color_mode == ColorMode.ACI:
+                rgb = RGB_NONE
             if self.map_black_rgb_to_white_rgb and rgb == BLACK_RGB:
                 rgb = WHITE_RGB
             if rgb is RGB_NONE:

src/ezdxf/addons/hpgl2/interpreter.py

@@ -14,76 +14,24 @@ class Interpreter:
     def __init__(self, plotter: Plotter) -> None:
         self.errors: list[str] = []
         self.not_implemented_commands: set[str] = set()
+        self._disabled_commands: set[str] = set()
         self.plotter = plotter
-        plotter.reset()
 
     def add_error(self, error: str) -> None:
         self.errors.append(error)
 
     def run(self, commands: list[Command]) -> None:
         for name, args in commands:
+            if name in self._disabled_commands:
+                continue
             method = getattr(self, f"cmd_{name.lower()}", None)
             if method:
                 method(args)
             elif name[0] in string.ascii_letters:
                 self.not_implemented_commands.add(name)
 
-    def cmd_escape(self, args: list[bytes]):
-        """Embedded PCL5 commands."""
-        if len(args):
-            self.plotter.execute_pcl5_command(args[0])
-
-    def cmd_pg(self, _):
-        """Advance full page."""
-        self.plotter.advance_full_page()
-
-    def cmd_rp(self, _):
-        """Replot."""
-        self.plotter.replot()
-
-    def cmd_wu(self, _):
-        """Pen width unit selection - not supported."""
-        pass
-
-    def cmd_la(self, _):
-        """Line attribute selection (line ends and line joins) - not supported."""
-        pass
-
-    def cmd_rf(self, _):
-        """Define raster fill - not supported."""
-        pass
-
-    def cmd_tr(self, _):
-        """Set transparency mode - not supported. Transparency mode is off, white
-        fillings cover graphics beneath.
-        """
-        pass
-
-    def cmd_ro(self, args: list[bytes]):
-        """Set rotation."""
-        angle: int = 0
-        if len(args):
-            angle = to_int(args[0], angle)
-        if angle in (0, 90, 180, 270):
-            self.plotter.rotate_coordinate_system(angle)
-        else:
-            self.add_error(f"invalid rotation angle {angle} for RO command")
-
-    def cmd_in(self, _):
-        """Initialize plotter."""
-        self.plotter.initialize()
-
-    def cmd_df(self, _):
-        """Reset to defaults."""
-        self.plotter.defaults()
-
-    def cmd_ps(self, args: list[bytes]):
-        """Set page size in plotter units - not documented."""
-        values = tuple(to_ints(args))
-        if len(values) != 2:
-            self.add_error("invalid arguments for command PS")
-            return
-        self.plotter.setup_page(values[0], values[1])
+    def disable_commands(self, commands: Iterable[str]) ->None:
+        self._disabled_commands.update(commands)
 
     # Configure pens, line types, fill types
     def cmd_ft(self, args: list[bytes]):
@@ -402,7 +350,7 @@ def cmd_fp(self, args: list[bytes]) -> None:
         """Plot filled polygon."""
         fill_method = 0
         if len(args):
-            fill_method = to_int(args[0], fill_method)
+            fill_method = one_of(to_int(args[0], fill_method), (0, 1))
         self.plotter.fill_polygon(fill_method)
 
     def cmd_ep(self, _) -> None:
@@ -456,3 +404,9 @@ def to_int(s: bytes, default=0) -> int:
 
 def clamp(v, v_min, v_max):
     return max(min(v_max, v), v_min)
+
+
+def one_of(value, choice):
+    if value in choice:
+        return value
+    return choice[0]

src/ezdxf/addons/hpgl2/page.py

@@ -14,7 +14,6 @@
 MM_TO_PLU = 40
 
 
-
 class Page:
     def __init__(self, size_x: int, size_y: int):
         self.size_x = int(size_x)  # in plotter units (plu)
@@ -26,12 +25,16 @@ def __init__(self, size_x: int, size_y: int):
         self.user_scale_x: float = 1.0
         self.user_scale_y: float = 1.0
         self.user_origin = NULLVEC2  # plu
+        self.rotation: int = 0
 
     def set_scaling_points(self, p1: Vec2, p2: Vec2) -> None:
         self.reset_scaling()
         self.p1 = Vec2(p1)
         self.p2 = Vec2(p2)
 
+    def apply_scaling_factors(self, sx: float, sy: float) -> None:
+        self.set_ucs(self.user_origin, self.user_scale_x * sx, self.user_scale_y * sy)
+
     def set_scaling_points_relative_1(self, xp1: float, yp1: float) -> None:
         size = self.p2 - self.p1
         p1 = Vec2(self.size_x * xp1, self.size_y * yp1)
@@ -110,7 +113,7 @@ def set_ucs(self, origin: Vec2, sx: float = 1.0, sy: float = 1.0):
 
     def set_rotation(self, angle: int) -> None:
         """Page rotation is not supported."""
-        pass
+        self.rotation = angle
 
     def page_point(self, x: float, y: float) -> Vec2:
         """Returns the page location as page point in plotter units."""
@@ -121,6 +124,8 @@ def page_vector(self, x: float, y: float) -> Vec2:
         if self.user_scaling:
             x = self.user_scale_x * x
             y = self.user_scale_y * y
+        if self.rotation:
+            return Vec2(x, y).rotate_deg(self.rotation)
         return Vec2(x, y)
 
     def page_points(self, points: Sequence[Vec2]) -> list[Vec2]: