plottool 0.1.0__py3-none-any.whl

hpglpreview.py

@@ -0,0 +1,382 @@
+#!/usr/bin/env python3
+
+import copy
+import math
+import wx
+from wx.lib.floatcanvas import FloatCanvas, GUIMode
+import hpgl
+import numpy
+
+# fix broken reference to float_ in wxPython 4.2.0
+FloatCanvas.float_ = numpy.float64
+
+HPGL2MM = hpgl.hpgl2mm(1)
+ZOOM_FACTOR = 1.3
+PAN_STEP = 50  # pixels per cursor-key press
+ARROW_SIZE = 50  # HPGL units (~1.25 mm)
+
+_MARKER_N = 20  # polygon sides used to approximate circles
+
+
+def _marker_pts(pt, radius):
+    return [(pt[0] + radius * math.cos(2 * math.pi * i / _MARKER_N),
+             pt[1] + radius * math.sin(2 * math.pi * i / _MARKER_N))
+            for i in range(_MARKER_N)]
+
+def _draw_start_marker(canvas, pt, color, radius):
+    """Filled polygon (pen-down / start of cut)."""
+    canvas.AddPolygon(_marker_pts(pt, radius), LineColor=color, FillColor=color)
+
+def _draw_end_marker(canvas, pt, color, radius):
+    """Circle outline polygon (pen-up / end of cut)."""
+    pts = _marker_pts(pt, radius)
+    pts.append(pts[0])  # close the loop
+    canvas.AddLine(pts, LineColor=color, LineWidth=2)
+
+def _draw_arrow(canvas, path, color):
+    """Draw a small V-shaped direction arrowhead at the midpoint of path."""
+    mid = max(1, len(path) // 2)
+    p1, p2 = path[mid - 1], path[mid]
+    dx, dy = p2[0] - p1[0], p2[1] - p1[1]
+    ln = math.hypot(dx, dy)
+    if ln < ARROW_SIZE * 0.5:
+        return
+    mx, my = (p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2
+    ux, uy = dx / ln, dy / ln
+    ca, sa = math.cos(math.radians(30)), math.sin(math.radians(30))
+    bx, by = -ux * ARROW_SIZE, -uy * ARROW_SIZE
+    w1 = (mx + ca * bx - sa * by, my + sa * bx + ca * by)
+    w2 = (mx + ca * bx + sa * by, my - sa * bx + ca * by)
+    canvas.AddLine([w1, (mx, my), w2], LineColor=color)
+
+
+class HPGLPreview(wx.Frame):
+
+    def __init__(self, hpgldata, title="HPGL preview", size=(1600, 900), dialog=False,
+                 show_endpoints=True, show_points=False,
+                 pristine_hpgl=None, transform_args=None, **kwargs):
+        super(HPGLPreview, self).__init__(parent=None, title=title, size=size, **kwargs)
+        self.checked = False
+        self._hpgl_paths = list(hpgldata.getPaths())
+        self._show_endpoints = show_endpoints
+        self._show_points = show_points
+        self.CreateStatusBar()
+
+        self.sizer = wx.BoxSizer(wx.VERTICAL)
+
+        # Toolbar: zoom in/out and fit-to-view.
+        tb = wx.BoxSizer(wx.HORIZONTAL)
+        self.btn_zoom_in  = wx.Button(self, label="+",   size=(30, 28))
+        self.btn_zoom_out = wx.Button(self, label="−",   size=(30, 28))
+        self.btn_fit      = wx.Button(self, label="Fit", size=(40, 28))
+        for btn in (self.btn_zoom_in, self.btn_zoom_out, self.btn_fit):
+            tb.Add(btn, 0, wx.LEFT | wx.TOP | wx.BOTTOM, 2)
+        self.sizer.Add(tb, 0, wx.ALL, 0)
+
+        # Interactive transform controls (only when a pristine copy is supplied)
+        self._pristine = None
+        if pristine_hpgl is not None:
+            self._pristine = pristine_hpgl
+            self._transform_args = transform_args
+            self._init_natural_size()
+            self._init_transform_values(transform_args)
+            self.sizer.Add(self._build_transform_panel(), 0, wx.ALL | wx.EXPAND, 2)
+
+        self.Canvas = FloatCanvas.FloatCanvas(self, -1, BackgroundColor="white")
+        self.sizer.Add(self.Canvas, 1, wx.ALL | wx.EXPAND)
+
+        # Summary bar
+        self.summary_label = wx.StaticText(self, label=self._make_summary(hpgldata),
+                                           style=wx.ALIGN_CENTER)
+        self.sizer.Add(self.summary_label, 0, wx.ALL | wx.EXPAND, 4)
+
+        hpgl_row = wx.BoxSizer(wx.HORIZONTAL)
+        hpgl_row.Add(wx.StaticText(self, label="Path HPGL:"), 0, wx.ALIGN_CENTER_VERTICAL | wx.LEFT, 4)
+        self.hpgl_field = wx.TextCtrl(self, style=wx.TE_READONLY | wx.TE_PROCESS_ENTER, size=(-1, -1))
+        hpgl_row.Add(self.hpgl_field, 1, wx.EXPAND | wx.LEFT | wx.RIGHT, 4)
+        self.sizer.Add(hpgl_row, 0, wx.ALL | wx.EXPAND, 2)
+
+        self.bsizer = wx.BoxSizer(wx.HORIZONTAL)
+        if dialog:
+            self.btn_ok = wx.Button(self, wx.ID_OK, label="OK")
+            self.btn_cancel = wx.Button(self, wx.ID_CANCEL, label="Cancel")
+            self.bsizer.AddStretchSpacer(1)
+            self.bsizer.Add(self.btn_ok, 0, wx.EXPAND | wx.RIGHT, 5)
+            self.bsizer.Add(self.btn_cancel, 0, wx.EXPAND | wx.LEFT, 5)
+            self.btn_ok.Bind(wx.EVT_BUTTON, self.OnOK)
+            self.btn_cancel.Bind(wx.EVT_BUTTON, self.OnCancel)
+            self.bsizer.AddStretchSpacer(1)
+            self.sizer.Add(self.bsizer, 0, wx.ALL | wx.EXPAND, 2)
+
+        self.SetSizer(self.sizer)
+
+        self._travel_pen = wx.Pen("blue", 1, wx.PENSTYLE_USER_DASH)
+        self._travel_pen.SetDashes([2, 12])
+        self._draw_canvas(hpgldata)
+
+        self.Canvas.SetMode(GUIMode.GUIMove())
+        self.btn_zoom_in.Bind(wx.EVT_BUTTON,  lambda e: self.Canvas.Zoom(ZOOM_FACTOR))
+        self.btn_zoom_out.Bind(wx.EVT_BUTTON, lambda e: self.Canvas.Zoom(1.0 / ZOOM_FACTOR))
+        self.btn_fit.Bind(wx.EVT_BUTTON,      lambda e: self.Canvas.ZoomToBB())
+        self.Canvas.Bind(wx.EVT_MOTION, self.OnMove)
+        self.Canvas.Bind(wx.EVT_RIGHT_DOWN, self.OnCanvasRightClick)
+        self.Bind(wx.EVT_CLOSE, self.OnClose)
+        self.Bind(wx.EVT_CHAR_HOOK, self.OnKeyDown)
+
+    # ── interactive transform controls ────────────────────────────────────
+
+    def _init_natural_size(self):
+        tmp = copy.deepcopy(self._pristine)
+        tmp.fit()
+        self._natural_w, self._natural_h = tmp.getSize()
+
+    def _init_transform_values(self, args):
+        if args is None or self._natural_w == 0:
+            self._tf_width = self._natural_w
+        elif getattr(args, 'width', None) is not None:
+            self._tf_width = args.width
+        elif getattr(args, 'scale', None) is not None:
+            self._tf_width = self._natural_w * args.scale
+        elif getattr(args, 'height', None) is not None and self._natural_h > 0:
+            self._tf_width = self._natural_w * args.height / self._natural_h
+        else:
+            self._tf_width = self._natural_w
+        self._tf_rotate = float(getattr(args, 'rotate', None) or 0.0)
+        self._tf_mirror = bool(getattr(args, 'mirror', False))
+        self._tf_flip   = bool(getattr(args, 'flip',   False))
+
+    def _build_transform_panel(self):
+        row = wx.BoxSizer(wx.HORIZONTAL)
+
+        row.Add(wx.StaticText(self, label="Width:"), 0, wx.ALIGN_CENTER_VERTICAL | wx.LEFT, 4)
+        self.spin_width = wx.SpinCtrlDouble(self, min=0.1, max=10000.0, inc=0.5,
+                                            style=wx.SP_ARROW_KEYS)
+        self.spin_width.SetDigits(1)
+        self.spin_width.SetValue(self._tf_width)
+        row.Add(self.spin_width, 0, wx.ALIGN_CENTER_VERTICAL | wx.LEFT, 2)
+        row.Add(wx.StaticText(self, label="mm"), 0, wx.ALIGN_CENTER_VERTICAL | wx.LEFT, 2)
+
+        init_h = (self._natural_h * self._tf_width / self._natural_w
+                  if self._natural_w > 0 else self._natural_h)
+        self.lbl_height = wx.StaticText(self, label="H: {:.1f} mm".format(init_h))
+        row.Add(self.lbl_height, 0, wx.ALIGN_CENTER_VERTICAL | wx.LEFT, 8)
+
+        row.Add(wx.StaticText(self, label="Rotate:"), 0, wx.ALIGN_CENTER_VERTICAL | wx.LEFT, 20)
+        self.spin_rotate = wx.SpinCtrlDouble(self, min=-360.0, max=360.0, inc=1.0)
+        self.spin_rotate.SetDigits(1)
+        self.spin_rotate.SetValue(self._tf_rotate)
+        row.Add(self.spin_rotate, 0, wx.ALIGN_CENTER_VERTICAL | wx.LEFT, 2)
+        row.Add(wx.StaticText(self, label="°"), 0, wx.ALIGN_CENTER_VERTICAL | wx.LEFT, 2)
+
+        self.chk_mirror = wx.CheckBox(self, label="Mirror")
+        self.chk_mirror.SetValue(self._tf_mirror)
+        row.Add(self.chk_mirror, 0, wx.ALIGN_CENTER_VERTICAL | wx.LEFT, 20)
+
+        self.chk_flip = wx.CheckBox(self, label="Flip")
+        self.chk_flip.SetValue(self._tf_flip)
+        row.Add(self.chk_flip, 0, wx.ALIGN_CENTER_VERTICAL | wx.LEFT, 8)
+
+        self.spin_width.Bind(wx.EVT_SPINCTRLDOUBLE, self._on_transform_change)
+        self.spin_rotate.Bind(wx.EVT_SPINCTRLDOUBLE, self._on_transform_change)
+        self.chk_mirror.Bind(wx.EVT_CHECKBOX, self._on_transform_change)
+        self.chk_flip.Bind(wx.EVT_CHECKBOX, self._on_transform_change)
+
+        return row
+
+    def _on_transform_change(self, _event):
+        self._redraw()
+
+    def _redraw(self):
+        width  = self.spin_width.GetValue()
+        rotate = self.spin_rotate.GetValue()
+        mirror = self.chk_mirror.GetValue()
+        flip   = self.chk_flip.GetValue()
+
+        hpgldata = copy.deepcopy(self._pristine)
+        if width > 0 and self._natural_w > 0:
+            hpgldata.scaleToWidth(width)
+        if rotate % 360 != 0:
+            hpgldata.rotate(rotate)
+        if mirror:
+            hpgldata.mirrorX()
+        if flip:
+            hpgldata.mirrorY()
+
+        _w, h = hpgldata.getSize()
+        self.lbl_height.SetLabel("H: {:.1f} mm".format(h))
+        self.summary_label.SetLabel(self._make_summary(hpgldata))
+        self._hpgl_paths = list(hpgldata.getPaths())
+
+        self.Canvas.ClearAll()
+        self._draw_canvas(hpgldata)
+        self.Canvas.Draw(True)
+
+    @property
+    def final_transform(self):
+        """Return the transform values chosen by the user, or None if no controls."""
+        if self._pristine is None:
+            return None
+        return {
+            'width':  getattr(self, '_final_width',  self._tf_width),
+            'rotate': getattr(self, '_final_rotate', self._tf_rotate),
+            'mirror': getattr(self, '_final_mirror', self._tf_mirror),
+            'flip':   getattr(self, '_final_flip',   self._tf_flip),
+        }
+
+    # ── canvas drawing ────────────────────────────────────────────────────
+
+    @staticmethod
+    def _make_summary(hpgldata):
+        w, h = hpgldata.getSize()
+        travel, draw = hpgldata.getLength()
+        n_paths = len(hpgldata.getPaths())
+        return ("Size: {:.1f} × {:.1f} mm  |  Area: {:.1f} cm²  |  "
+                "Paths: {}  |  Cut: {:.1f} cm  |  Travel: {:.1f} cm"
+                ).format(w, h, w / 10 * h / 10, n_paths, draw / 10, travel / 10)
+
+    def _draw_canvas(self, hpgldata):
+        last = (0, 0)
+        for line in hpgldata.getPaths():
+            self.Canvas.AddLine(line)
+            _draw_arrow(self.Canvas, line, "black")
+            if self._show_points:
+                for pt in line:
+                    _draw_start_marker(self.Canvas, pt, "LightBlue", ARROW_SIZE * 0.35)
+            travel = [last, line[0]]
+            travel_obj = self.Canvas.AddLine(travel, LineColor="blue")
+            travel_obj.Pen = self._travel_pen
+            _draw_arrow(self.Canvas, travel, "blue")
+            if self._show_endpoints:
+                _draw_start_marker(self.Canvas, line[0],  "SteelBlue", ARROW_SIZE * 0.6)
+                _draw_end_marker(  self.Canvas, line[-1], "DarkBlue",  ARROW_SIZE)
+            last = line[-1]
+        home = [last, (0, 0)]
+        self.Canvas.AddLine(home, LineColor="green")
+        _draw_arrow(self.Canvas, home, "green")
+        m, mm = hpgldata.getBoundingBox()
+        self.Canvas.AddRectangle((0, 0), (mm[0] + m[0], mm[1] + m[1]), LineColor="orange")
+        if hasattr(hpgldata, '_design_bbox'):
+            dm, dmm = hpgldata._design_bbox
+            self.Canvas.AddRectangle((dm[0], dm[1]), (dmm[0] - dm[0], dmm[1] - dm[1]),
+                                     LineColor="green")
+
+    # ── event handlers ────────────────────────────────────────────────────
+
+    def _segment_dist(self, px, py, ax, ay, bx, by):
+        """Minimum distance from point (px,py) to segment (ax,ay)-(bx,by)."""
+        dx, dy = bx - ax, by - ay
+        if dx == 0 and dy == 0:
+            return math.hypot(px - ax, py - ay)
+        t = max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy)))
+        return math.hypot(px - (ax + t * dx), py - (ay + t * dy))
+
+    def _nearest_path_index(self, wx_coord, wy_coord):
+        best_idx, best_dist = 0, float('inf')
+        for i, path in enumerate(self._hpgl_paths):
+            for j in range(len(path) - 1):
+                d = self._segment_dist(wx_coord, wy_coord,
+                                       path[j][0], path[j][1],
+                                       path[j + 1][0], path[j + 1][1])
+                if d < best_dist:
+                    best_dist, best_idx = d, i
+        return best_idx
+
+    @staticmethod
+    def _path_to_hpgl(path):
+        first = path[0]
+        rest = path[1:]
+        coords = ",".join("{:d},{:d}".format(int(round(x)), int(round(y))) for x, y in rest)
+        return "PU{:d},{:d};PD{};".format(int(round(first[0])), int(round(first[1])), coords)
+
+    def OnCanvasRightClick(self, event):
+        world = self.Canvas.PixelToWorld(event.GetPosition())
+        idx = self._nearest_path_index(world[0], world[1])
+        self.hpgl_field.SetValue(self._path_to_hpgl(self._hpgl_paths[idx]))
+        self.hpgl_field.SelectAll()
+        event.Skip()
+
+    def OnKeyDown(self, event):
+        key = event.GetKeyCode()
+        if key in (wx.WXK_RETURN, wx.WXK_NUMPAD_ENTER):
+            self.OnOK(event)
+        elif key == wx.WXK_ESCAPE:
+            self.OnCancel(event)
+        elif key in (ord('+'), ord('='), wx.WXK_NUMPAD_ADD):
+            self.Canvas.Zoom(ZOOM_FACTOR)
+        elif key in (ord('-'), wx.WXK_NUMPAD_SUBTRACT):
+            self.Canvas.Zoom(1.0 / ZOOM_FACTOR)
+        elif key in (ord('f'), ord('F')):
+            self.Canvas.ZoomToBB()
+        elif key == wx.WXK_LEFT:
+            self.Canvas.MoveImage((-PAN_STEP, 0), 'Pixel')
+        elif key == wx.WXK_RIGHT:
+            self.Canvas.MoveImage((PAN_STEP, 0), 'Pixel')
+        elif key == wx.WXK_UP:
+            self.Canvas.MoveImage((0, -PAN_STEP), 'Pixel')
+        elif key == wx.WXK_DOWN:
+            self.Canvas.MoveImage((0, PAN_STEP), 'Pixel')
+        else:
+            event.Skip()
+
+    def OnOK(self, event):
+        self.checked = True
+        if self._pristine is not None:
+            self._final_width  = self.spin_width.GetValue()
+            self._final_rotate = self.spin_rotate.GetValue()
+            self._final_mirror = self.chk_mirror.GetValue()
+            self._final_flip   = self.chk_flip.GetValue()
+        self.Close()
+
+    def OnCancel(self, event):
+        self.Close()
+
+    def OnMove(self, event):
+        coords = self.Canvas.PixelToWorld(event.GetPosition())
+        self.SetStatusText("%.2f mm, %.2f mm" % (coords[0] * HPGL2MM, coords[1] * HPGL2MM))
+        event.Skip()
+
+    def OnClose(self, event):
+        self.eventLoop.Exit()
+
+    def ShowModal(self):
+        if hasattr(self, "MakeModal"):
+            self.MakeModal()  # removed in wxPython 4.x; present on older versions
+        self.Show()
+        self.Canvas.ZoomToBB()
+
+        self.eventLoop = wx.GUIEventLoop()
+        self.eventLoop.Run()
+        self.Destroy()
+        return self.checked
+
+
+if __name__ == "__main__":
+    import argparse
+    app = wx.App(False)
+    parser = argparse.ArgumentParser("HPGL preview")
+    parser.add_argument("file", type=str, help="the HPGL-file to open")
+    weed_group = parser.add_argument_group("weeding lines")
+    weed_group.add_argument("--weed", metavar="STRATEGY",
+                            choices=["grid", "horizontal", "vertical", "frame",
+                                     "diagonal", "rombic", "tick", "radial"],
+                            help="Add weeding lines")
+    weed_group.add_argument("--weed-size", metavar="PCT", type=float, default=25.0)
+    weed_group.add_argument("--weed-small-size", metavar="PCT", type=float, default=0.0)
+    weed_group.add_argument("--weed-min-size", metavar="PCT", type=float, default=0.0)
+    weed_group.add_argument("--weed-min-x", metavar="MM", type=float, default=1.0)
+    weed_group.add_argument("--weed-max-x", metavar="MM", type=float, default=None)
+    weed_group.add_argument("--weed-min-y", metavar="MM", type=float, default=1.0)
+    weed_group.add_argument("--weed-max-y", metavar="MM", type=float, default=None)
+    weed_group.add_argument("--weed-margin", metavar="MM", type=float, default=2.0)
+    weed_group.add_argument("--weed-tick-length", metavar="MM", type=float, default=5.0)
+    weed_group.add_argument("--no-weed-adaptive", action="store_true")
+    weed_group.add_argument("--no-weed-frame", action="store_true")
+    weed_group.add_argument("--weed-frame-distance", metavar="MM", type=float, default=1.0)
+    args = parser.parse_args()
+
+    hpglfile = hpgl.HPGL(args.file)
+    pristine = copy.deepcopy(hpglfile)
+    hpgl.apply_args(hpglfile, args)
+
+    dialog = HPGLPreview(hpglfile, pristine_hpgl=pristine)
+    dialog.ShowModal()

plottool-0.1.0.dist-info/METADATA

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: plottool
+Version: 0.1.0
+Summary: HPGL plotter/cutter tool with serial port support, path optimization, blade offset compensation, preview, and weeding lines
+Author-email: Till Uhde <till@uhde.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyserial
+Requires-Dist: numpy
+Requires-Dist: wxPython
+Dynamic: license-file
+
+plottool
+========
+
+A tool for sending HPGL files to a plotter or cutting plotter connected over a
+serial port. Includes path optimization, blade offset compensation, scaling,
+rotation, tiling, weeding lines, config profiles, and a graphical preview window.
+
+Tested with a Cogi CT-630 cutting plotter @ Stratum0:
+https://stratum0.org/wiki/Cogi_CT-630
+
+Also works on macOS, but less reliably — prepare for occasional job cancellation.
+
+> Forked from [stratum0/plottool](https://github.com/stratum0/plottool).
+
+> This project is being actively extended with the help of
+> [Claude Code](https://claude.ai/code) (Anthropic AI).
+
+
+Dependencies
+------------
+
+For Debian-based Linux distributions (Ubuntu, Mint):
+
+```
+sudo apt-get install python3-serial python3-wxgtk4.0 python3-numpy
+```
+
+For Arch Linux:
+
+```
+sudo pacman -S python-numpy python-pyserial python-wxpython
+```
+
+For macOS (homebrew + pip):
+
+```
+pip install numpy pyserial && brew install wxpython
+```
+
+Or install via pip from the repository root:
+
+```
+pip install .
+```
+
+
+Usage — plottool.py
+--------------------
+
+Send an HPGL file to the plotter:
+
+```
+./plottool.py file.hpgl
+./plottool.py file.hpgl -m --width 200
+./plottool.py file.hpgl --profile vinyl
+```
+
+**Options:**
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--profile NAME` | — | Load a config profile (see Config file) |
+| `-p`, `--port PORT` | `/dev/ttyUSB0` | Serial port |
+| `-b`, `--baud BAUD` | `9600` | Serial baud rate |
+| `-m`, `--magic` | off | Auto-optimize: point reduction + blade offset + reroute |
+| `-w`, `--width MM` | — | Scale to width in mm (mutually exclusive with `-H`, `-s`) |
+| `-H`, `--height MM` | — | Scale to height in mm (mutually exclusive with `-w`, `-s`) |
+| `-s`, `--scale FACTOR` | — | Scale by factor, e.g. `0.5` for half size (mutually exclusive with `-w`, `-H`) |
+| `--mirror` | off | Flip left-right (for inverted cuts, e.g. T-shirts) |
+| `--flip` | off | Flip top-bottom |
+| `--rotate DEG` | — | Rotate counter-clockwise by DEG degrees (uses axis swaps at multiples of 90°) |
+| `-v`, `--preview` | off | Show preview window before plotting |
+| `-o`, `--output FILE` | — | Save processed HPGL to FILE before plotting |
+| `--pen` | off | Disable blade offset compensation (use for pen plotters) |
+| `--blade-offset MM` | `0.25` | Blade trailing offset in mm (ignored with `--pen`) |
+| `--no-blade-prep` | off | Skip the 2 mm seating cut at origin |
+| `--reroute {xy,nearest,none}` | `xy` | Path order: `xy` = boustrophedon rows, `nearest` = greedy nearest-neighbour, `none` = original |
+| `--repeat-x N` | `1` | Tile the design N times along X |
+| `--repeat-y N` | `1` | Tile the design N times along Y |
+| `--gap MM` | `5` | Gap between tiles (both axes) |
+| `--gap-x MM` | — | Gap along X, overrides `--gap` (negative = overlap) |
+| `--gap-y MM` | — | Gap along Y, overrides `--gap` (negative = overlap) |
+| `--offset-x MM` | `0` | X offset per Y-step (stagger rows) |
+| `--offset-y MM` | `0` | Y offset per X-step (stagger columns) |
+| `--weed STRATEGY` | — | Add weeding lines (see Weeding lines) |
+| `--weed-size PCT` | `25` | Max waste piece size as % of bbox area |
+| `--weed-min-x MM` | `1` | Min spacing between vertical weeding lines |
+| `--weed-max-x MM` | — | Max spacing between vertical weeding lines |
+| `--weed-min-y MM` | `1` | Min spacing between horizontal weeding lines |
+| `--weed-max-y MM` | — | Max spacing between horizontal weeding lines |
+| `--weed-margin MM` | `2` | Extend weeding lines beyond bbox |
+| `--weed-tick-length MM` | `5` | Tick/comb tooth length |
+| `--weed-small-size PCT` | auto | Radial inner circle area (default: weed-size/10) |
+| `--weed-min-size PCT` | auto | Drop lines creating waste pieces smaller than this |
+| `--weed-frame-distance MM` | `1` | Distance of outer frame from bbox |
+| `--no-weed-frame` | — | Suppress the automatic outer frame |
+| `--no-weed-adaptive` | — | Disable adaptive clipping at design intersections |
+
+On macOS, serial devices follow a different naming convention — look for something
+like `/dev/tty.usbserial-14430` or `/dev/cu.usbserial-14430`.
+
+
+Usage — hpgl.py
+----------------
+
+Process an HPGL file without plotting (convert, optimise, preview, export):
+
+```
+./hpgl.py file.hpgl -o out.hpgl -p preview.svg
+./hpgl.py file.hpgl -m --rotate 90 -o out.hpgl
+```
+
+Supports all flags from `plottool.py` except `--port`, `--baud`, and `--preview`
+(which is `-p SVG` here, exporting to an SVG file instead of opening a window).
+
+
+Processing pipeline
+-------------------
+
+When multiple options are active, they are applied in this order:
+
+1. **Scale** (`--width` / `--height` / `--scale`)
+2. **Rotate** (`--rotate`)
+3. **Mirror** (`--mirror`) — flip left-right
+4. **Flip** (`--flip`) — flip top-bottom
+5. **Optimize** (`--magic`) — remove redundant points, fit to origin
+6. **Blade offset** (`--magic`) — overshoot correction at corners
+7. **Tile** (`--repeat-x` / `--repeat-y`)
+8. **Weeding lines** (`--weed`)
+9. **Reroute** (`--reroute`) — reorder paths for travel efficiency
+10. **Blade prep cut** — 2 mm seating cut prepended at origin (disable with `--no-blade-prep`)
+
+
+Weeding lines
+-------------
+
+Add cut lines to help remove waste vinyl after cutting. Select a strategy with
+`--weed STRATEGY`:
+
+| Strategy | Description |
+|----------|-------------|
+| `grid` | Horizontal + vertical lines across the bbox |
+| `horizontal` | Horizontal lines only |
+| `vertical` | Vertical lines only |
+| `diagonal` | 45° lines across the bbox |
+| `rombic` | Both diagonal families (diamond grid) |
+| `frame` | Concentric equal-area rectangles stepping inward |
+| `tick` | Short inward comb-teeth from each bbox edge |
+| `radial` | Evenly-angled spokes from the bbox centre |
+
+Line density is controlled by `--weed-size PCT` (max waste piece size as % of bbox
+area, default 25). All strategies support **adaptive clipping** (default on): weeding
+lines are split at design intersections so only waste-area segments are kept. An outer
+frame rectangle (1 mm from bbox by default) is added automatically.
+
+See [WEEDING_LINES.md](WEEDING_LINES.md) for full parameter details.
+
+
+Config file
+-----------
+
+Settings can be stored in `~/.plottoolrc` (global) or `plottool.conf` in the current
+directory (local, takes precedence). The format is INI:
+
+```ini
+[default]
+magic = true
+blade-offset = 0.3
+
+[vinyl]
+width = 300
+reroute = nearest
+
+[shirt]
+mirror = true
+width = 300
+
+[pen]
+pen = true
+no-blade-prep = true
+```
+
+The `[default]` section always applies. Use `--profile NAME` to also apply a named
+section on top. Command-line arguments always override config values. See
+`plottool.conf.example` for a full annotated example.
+
+
+Preview window
+--------------
+
+The preview window (`-v` in `plottool.py`, `-p SVG` exports to file in `hpgl.py`)
+shows the processed paths with:
+
+- Direction arrows on cut paths, travel moves, and the return-to-origin line
+- Dotted travel (pen-up) lines
+- Start-of-cut (filled blue dot) and end-of-cut (blue ring) markers at every pen transition
+- The design bounding box before weeding lines are added (green rectangle)
+
+Interactive controls (plottool.py preview window):
+
+| Input | Action |
+|-------|--------|
+| Left-drag | Pan |
+| Scroll wheel | Zoom (centred on cursor) |
+| `+` / `=` | Zoom in |
+| `-` | Zoom out |
+| `f` | Fit view |
+| Arrow keys | Pan |
+| Enter | Confirm and proceed to plot |
+| Esc | Cancel |

plottool-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+hpgl.py,sha256=IOMdExu_pun1XKtXRUkF3Ww_MunakTfrQ7o8mh6HX84,49300
+hpglpreview.py,sha256=AKUZyTMLE_rGQmpinxP92rOgGOh9QW_0An6PTGIXCvs,16927
+plottool.py,sha256=52vMFLUStjMURLU7OCnjQuuKMVWnw5mEWSa4HabwZZo,10587
+plottool-0.1.0.dist-info/licenses/LICENSE,sha256=SHi4lLkD-yJ56xZkQ_8aPzzKOS7d8Fm5hknIYjVoLF0,1066
+plottool-0.1.0.dist-info/METADATA,sha256=MvlnW8spNiRi0zZdWX4MjAMMSubVTfYvPeiO3cjDajA,7975
+plottool-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+plottool-0.1.0.dist-info/entry_points.txt,sha256=Yk_qGcVaEtzmWTavsML-DPqqWx7FAX9ly-1nnnUtxZM,43
+plottool-0.1.0.dist-info/top_level.txt,sha256=6rK-hScTXOIe55Sz_HT1aQGNByrbEMP-Nz9hlFENXTU,26
+plottool-0.1.0.dist-info/RECORD,,

plottool-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

plottool-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+plottool = plottool:main

plottool-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Till Uhde
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

plottool-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+hpgl
+hpglpreview
+plottool