drydock-cli 2.10.10__tar.gz → 2.10.12__tar.gz

{drydock_cli-2.10.10 → drydock_cli-2.10.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.10.10
+Version: 2.10.12
 Summary: Local-first TUI coding agent for Gemma 4 + llama.cpp, with GraphRAG retrieval and a curated cookbook of domain recipes.
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

drydock_cli-2.10.12/drydock/data/cookbook/tbench_domains/gcode_to_text.md

@@ -0,0 +1,184 @@
+# G-code-to-text via Prusa toolpath rendering + OCR
+
+Used by: `gcode-to-text`. Task ships a `text.gcode` for a Prusa MK4s
+that prints **text on top of an existing object**. The print
+toolpath traces letter shapes onto a flat surface. Goal: parse the
+G-code, render the toolpath, and OCR the result.
+
+Output: `/app/out.txt` containing the printed text.
+
+## Why this is hard
+
+The model can't read G-code as text directly — G-code is a coordinate
+sequence for the printer head, not human-readable characters. The
+letters only appear when you:
+
+1. Plot the X/Y/Z trajectories of extrusion moves
+2. Apply the right Euler rotation so the text becomes face-up
+3. Save as a 2D image
+4. OCR it
+
+The right rotation (`alpha=0, beta=201, gamma=0` Z-Y-X order) flips
+the print orientation so the text reads correctly. Other angles
+produce gibberish OCR.
+
+## Reference solution shape
+
+Three Python scripts run in sequence:
+
+### Step 1: `makeseg.py` — parse G-code into 3D segments
+
+```python
+import re, pickle
+
+x = y = z = 0.0
+segments = []   # [((x1,y1,z1), (x2,y2,z2)), ...]
+
+with open('/app/text.gcode') as f:
+    for line in f:
+        line = line.split(';')[0].strip()        # strip comments
+        if not (line.startswith('G0') or line.startswith('G1')):
+            continue
+
+        z_m = re.search(r'Z([+-]?\d+\.?\d*)', line)
+        x_m = re.search(r'X([+-]?\d+\.?\d*)', line)
+        y_m = re.search(r'Y([+-]?\d+\.?\d*)', line)
+        e_m = re.search(r'E([+-]?\d+\.?\d*)', line)
+
+        if z_m: z = float(z_m.group(1))
+        new_x = float(x_m.group(1)) if x_m else x
+        new_y = float(y_m.group(1)) if y_m else y
+
+        # Only EXTRUSION moves (e>0) draw text
+        if e_m and (x_m or y_m) and float(e_m.group(1)) > 0:
+            segments.append(((x, y, z), (new_x, new_y, z)))
+
+        x, y = new_x, new_y
+
+with open('/tmp/gcode_3d_segments.pkl', 'wb') as f:
+    pickle.dump(segments, f)
+```
+
+### Step 2: `render.py` — 3D → 2D image with Euler rotation
+
+```python
+import pickle, sys
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+
+alpha, beta, gamma = float(sys.argv[1]), float(sys.argv[2]), float(sys.argv[3])
+
+def euler_rotation_matrix(a, b, c):
+    a, b, c = np.radians([a, b, c])
+    Rz = np.array([[np.cos(a),-np.sin(a),0],[np.sin(a),np.cos(a),0],[0,0,1]])
+    Ry = np.array([[np.cos(b),0,np.sin(b)],[0,1,0],[-np.sin(b),0,np.cos(b)]])
+    Rx = np.array([[1,0,0],[0,np.cos(c),-np.sin(c)],[0,np.sin(c),np.cos(c)]])
+    return Rz @ Ry @ Rx
+
+R = euler_rotation_matrix(alpha, beta, gamma)
+segs = pickle.load(open('/tmp/gcode_3d_segments.pkl','rb'))
+
+# Apply rotation to each endpoint
+rotated = [(R @ np.array(p1), R @ np.array(p2)) for p1, p2 in segs]
+
+# Plot in 2D (project to XY plane after rotation)
+fig, ax = plt.subplots(figsize=(20, 10))
+for p1, p2 in rotated:
+    ax.plot([p1[0], p2[0]], [p1[1], p2[1]], 'k-', linewidth=1.5)
+ax.set_aspect('equal')
+ax.axis('off')
+plt.tight_layout()
+plt.savefig('/app/rendered.png', dpi=200, bbox_inches='tight')
+```
+
+### Step 3: `ocr.py` — read with tesseract
+
+```python
+import cv2, pytesseract
+from PIL import Image
+
+img = cv2.imread('/app/rendered.png', cv2.IMREAD_GRAYSCALE)
+# Threshold + invert if background is dark
+_, binary = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)
+# (Optional) Crop / cleanup here
+
+text = pytesseract.image_to_string(
+    Image.fromarray(binary),
+    config=r'--oem 3 --psm 6',
+)
+
+with open('/app/out.txt', 'w') as f:
+    f.write(text)
+```
+
+### Drive script: `solve.sh`
+
+```bash
+#!/bin/bash
+set -e
+apt-get update -y
+apt-get install -y tesseract-ocr libtesseract-dev python3-opencv
+pip install matplotlib pytesseract pillow opencv-python
+
+python3 makeseg.py
+python3 render.py 0 201 0    # ← the magic angles!
+python3 ocr.py
+```
+
+## Critical: the right Euler angles
+
+`alpha=0, beta=201, gamma=0` (Z-Y-X order in degrees). The β=201°
+rotation is the one that flips the print into reading orientation.
+
+If you can't intuit the rotation, try a small sweep:
+```python
+for beta in (0, 90, 180, 201, 270):
+    # render + OCR each, keep the one whose OCR returned the most
+    # recognizable text (use language model confidence or word-count)
+```
+
+The "201" comes from the printer's tilted print bed + post-print
+rotation; β=180 + a small tilt correction.
+
+## Pitfalls
+
+1. **Tesseract config**: `--psm 6` (single uniform block of text)
+   beats default. `--psm 7` (single line) sometimes better for
+   short text.
+2. **DPI matters**: 200 dpi minimum for readable letters.
+   100 dpi makes tesseract miss strokes.
+3. **Line width**: too thin (default 1.0) and the OCR sees broken
+   characters. `linewidth=1.5` gives solid strokes.
+4. **Z-range filtering**: only extruded moves on the print's TOP
+   surface form the text. If the toolpath also has prep moves
+   below the surface, filter to z >= max_z - threshold.
+5. **`figsize` vs `bbox_inches='tight'`**: without tight bbox,
+   matplotlib adds white margins that distort tesseract's
+   layout analysis.
+6. **Comment stripping**: G-code comments after `;` can contain
+   numbers that match `X/Y/Z(\d+)` and corrupt the parser. Always
+   strip with `line.split(';')[0]` before regex matching.
+7. **Output file ends with newline**: tesseract appends a `\n`;
+   the verifier usually strips, but if exact-match check fails,
+   try writing `text.rstrip('\n')`.
+
+## Verification approach
+
+The verifier reads `/app/out.txt` and compares against expected text
+(case-insensitive substring usually). If your output has the right
+words but extra noise, that often still passes.
+
+For diagnostic:
+```bash
+cat /app/out.txt
+# If empty or garbage, the rotation is wrong — try other betas.
+# If readable but lowercase/UPPERCASE mismatch, tesseract sometimes
+# capitalizes — let the verifier handle case.
+```
+
+## Common task shape variants
+
+The text content varies per setup. Could be a single word, a sentence,
+or multiline. The parsing + render approach is the same; only the
+final OCR string changes.