@linkiez/dxf-renew 7.0.0 → 7.2.0

package/tools/ezdxf_generate_dimensions_all_types.py

@@ -0,0 +1,246 @@
+"""Generate per-type DIMENSION fixtures.
+
+This script generates one DXF fixture per DXF DIMENSION type used by our renderer.
+
+Usage:
+  ./.venv-ezdxf/bin/python tools/ezdxf_generate_dimensions_all_types.py
+
+Output:
+  test/resources/dimension-type-0-linear.dxf
+  test/resources/dimension-type-1-aligned.dxf
+  test/resources/dimension-type-2-angular-2l.dxf
+  test/resources/dimension-type-3-diameter.dxf
+  test/resources/dimension-type-4-radius.dxf
+  test/resources/dimension-type-5-angular-3p.dxf
+  test/resources/dimension-type-6-ordinate-x.dxf
+    test/resources/dimension-type-6-ordinate-y.dxf
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import ezdxf
+
+
+def _out_path(name: str) -> Path:
+    repo_root = Path(__file__).resolve().parents[1]
+    return repo_root / "test" / "resources" / name
+
+
+def _new_doc() -> ezdxf.EzDxf:
+    doc = ezdxf.new("R2010")
+    doc.header["$INSUNITS"] = 4  # millimeters
+    return doc
+
+
+def generate_type_0_linear() -> None:
+    out_path = _out_path("dimension-type-0-linear.dxf")
+    doc = _new_doc()
+    msp = doc.modelspace()
+
+    # Reference geometry
+    p1 = (10.0, 10.0)
+    p2 = (110.0, 10.0)
+    msp.add_line(p1, p2)
+
+    dim = msp.add_linear_dim(
+        base=(10.0, 35.0),
+        p1=p1,
+        p2=p2,
+        angle=0,
+        text="<>",
+        dimstyle="EZDXF",
+    )
+    dim.update({"dimdec": 2})
+    dim.render()
+
+    doc.saveas(out_path)
+    print(f"Wrote {out_path}")
+
+
+def generate_type_1_aligned() -> None:
+    out_path = _out_path("dimension-type-1-aligned.dxf")
+    doc = _new_doc()
+    msp = doc.modelspace()
+
+    # Reference geometry along a slope
+    p1 = (10.0, 10.0)
+    p2 = (90.0, 50.0)
+    msp.add_line(p1, p2)
+
+    # distance is the offset from the measured line
+    dim = msp.add_aligned_dim(
+        p1=p1,
+        p2=p2,
+        distance=20.0,
+        text="<>",
+        dimstyle="EZDXF",
+    )
+    dim.update({"dimdec": 2})
+    dim.render()
+
+    doc.saveas(out_path)
+    print(f"Wrote {out_path}")
+
+
+def generate_type_2_angular_2l() -> None:
+    out_path = _out_path("dimension-type-2-angular-2l.dxf")
+    doc = _new_doc()
+    msp = doc.modelspace()
+
+    # Two lines meeting at the origin (vertex)
+    center = (0.0, 0.0)
+    p1 = (100.0, 0.0)
+    p2 = (0.0, 80.0)
+    msp.add_line(center, p1)
+    msp.add_line(center, p2)
+
+    # line1 and line2 each defined by (start, end)
+    dim = msp.add_angular_dim_2l(
+        base=(50.0, 50.0),
+        line1=(center, p1),
+        line2=(center, p2),
+        text="<>",
+        dimstyle="EZ_CURVED",
+    )
+    dim.update({"dimdec": 2})
+    dim.render()
+
+    doc.saveas(out_path)
+    print(f"Wrote {out_path}")
+
+
+def generate_type_3_diameter() -> None:
+    out_path = _out_path("dimension-type-3-diameter.dxf")
+    doc = _new_doc()
+    msp = doc.modelspace()
+
+    center = (60.0, 40.0)
+    radius = 25.0
+    msp.add_circle(center, radius)
+
+    dim = msp.add_diameter_dim(
+        center=center,
+        radius=radius,
+        location=(center[0] + 40.0, center[1] + 30.0),
+        text="<>",
+        dimstyle="EZ_RADIUS",
+    )
+    dim.update({"dimdec": 2})
+    dim.render()
+
+    doc.saveas(out_path)
+    print(f"Wrote {out_path}")
+
+
+def generate_type_4_radius() -> None:
+    out_path = _out_path("dimension-type-4-radius.dxf")
+    doc = _new_doc()
+    msp = doc.modelspace()
+
+    center = (60.0, 40.0)
+    radius = 30.0
+    msp.add_circle(center, radius)
+
+    dim = msp.add_radius_dim(
+        center=center,
+        radius=radius,
+        location=(center[0] + 45.0, center[1] + 20.0),
+        text="<>",
+        dimstyle="EZ_RADIUS",
+    )
+    dim.update({"dimdec": 2})
+    dim.render()
+
+    doc.saveas(out_path)
+    print(f"Wrote {out_path}")
+
+
+def generate_type_5_angular_3p() -> None:
+    # Keep this aligned with tools/ezdxf_generate_dimensions_angular_3p.py
+    out_path = _out_path("dimension-type-5-angular-3p.dxf")
+    doc = _new_doc()
+    msp = doc.modelspace()
+
+    center = (0.0, 0.0)
+    p1 = (100.0, 0.0)
+    p2 = (0.0, 120.0)
+    msp.add_line(center, p1)
+    msp.add_line(center, p2)
+
+    dim = msp.add_angular_dim_3p(
+        base=(80.0, 80.0),
+        center=center,
+        p1=p1,
+        p2=p2,
+        text="<>",
+        dimstyle="EZ_CURVED",
+    )
+    dim.update({"dimdec": 2})
+    dim.render()
+
+    doc.saveas(out_path)
+    print(f"Wrote {out_path}")
+
+
+def generate_type_6_ordinate_x() -> None:
+    out_path = _out_path("dimension-type-6-ordinate-x.dxf")
+    doc = _new_doc()
+    msp = doc.modelspace()
+
+    feature = (70.0, 30.0)
+    msp.add_point(feature)
+
+    # offset is from the feature location to the leader end (where the text sits).
+    dim = msp.add_ordinate_x_dim(
+        feature_location=feature,
+        offset=(30.0, 25.0),
+        origin=(0.0, 0.0),
+        rotation=0.0,
+        text="<>",
+        dimstyle="EZDXF",
+    )
+    dim.update({"dimdec": 2})
+    dim.render()
+
+    doc.saveas(out_path)
+    print(f"Wrote {out_path}")
+
+
+def generate_type_6_ordinate_y() -> None:
+    out_path = _out_path("dimension-type-6-ordinate-y.dxf")
+    doc = _new_doc()
+    msp = doc.modelspace()
+
+    feature = (40.0, 90.0)
+    msp.add_point(feature)
+
+    dim = msp.add_ordinate_y_dim(
+        feature_location=feature,
+        offset=(25.0, 30.0),
+        origin=(0.0, 0.0),
+        rotation=0.0,
+        text="<>",
+        dimstyle="EZDXF",
+    )
+    dim.update({"dimdec": 2})
+    dim.render()
+
+    doc.saveas(out_path)
+    print(f"Wrote {out_path}")
+
+
+def main() -> None:
+    generate_type_0_linear()
+    generate_type_1_aligned()
+    generate_type_2_angular_2l()
+    generate_type_3_diameter()
+    generate_type_4_radius()
+    generate_type_5_angular_3p()
+    generate_type_6_ordinate_x()
+    generate_type_6_ordinate_y()
+
+
+if __name__ == "__main__":
+    main()

package/tools/ezdxf_generate_dimensions_angular_3p.py

@@ -0,0 +1,59 @@
+"""Generate an angular 3-point DIMENSION fixture DXF.
+
+This fixture is meant to exercise DIMENSION type 5 (Angular 3-point).
+
+Usage:
+  ./.venv-ezdxf/bin/python tools/ezdxf_generate_dimensions_angular_3p.py
+
+Output:
+  test/resources/dimensions-angular-3p.dxf
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import ezdxf
+
+
+def main() -> None:
+    repo_root = Path(__file__).resolve().parents[1]
+    out_path = repo_root / "test" / "resources" / "dimensions-angular-3p.dxf"
+
+    doc = ezdxf.new("R2010")
+    doc.header["$INSUNITS"] = 4  # millimeters
+    msp = doc.modelspace()
+
+    # Geometry: two rays forming an angle at "center".
+    center = (0.0, 0.0)
+    p1 = (100.0, 0.0)
+    p2 = (0.0, 120.0)
+
+    # Draw legs for visual reference.
+    msp.add_line(center, p1)
+    msp.add_line(center, p2)
+
+    # Place the dimension arc at a larger radius.
+    base = (80.0, 80.0)
+
+    # ezdxf renders DIMENSION via an anonymous block; our renderer uses the DIMENSION
+    # entity definition points.
+    dim = msp.add_angular_dim_3p(
+        base=base,
+        center=center,
+        p1=p1,
+        p2=p2,
+        text="<>",
+        dimstyle="EZDXF",
+    )
+
+    # Ensure deterministic text formatting.
+    dim.update({"dimdec": 2})
+    dim.render()
+
+    doc.saveas(out_path)
+    print(f"Wrote {out_path}")
+
+
+if __name__ == "__main__":
+    main()

package/tools/ezdxf_generate_dimensions_large_scale.py

@@ -0,0 +1,87 @@
+"""Generate a large-scale DIMENSION fixture DXF.
+
+This fixture is meant to exercise viewport-based DIMENSION autoScale.
+It intentionally uses a very large modelspace extent so that autoScale
+has a noticeable effect in rendering.
+
+Usage:
+  ./.venv-ezdxf/bin/python tools/ezdxf_generate_dimensions_large_scale.py
+
+Output:
+  test/resources/dimensions-large-scale.dxf
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import ezdxf
+
+
+def main() -> None:
+    repo_root = Path(__file__).resolve().parents[1]
+    out_path = repo_root / "test" / "resources" / "dimensions-large-scale.dxf"
+
+    doc = ezdxf.new("R2010")
+    doc.header["$INSUNITS"] = 4  # millimeters
+    msp = doc.modelspace()
+
+    # Large geometry: very large extents so viewport-based autoScale has a
+    # noticeable effect.
+    base_x = 0.0
+    base_y = 0.0
+
+    length = 80000.0
+    p1 = (base_x + 10000.0, base_y + 20000.0)
+    p2 = (base_x + 10000.0 + length, base_y + 20000.0)
+
+    # Draw a rectangle below the dimension line to resemble the existing fixture.
+    rect_min = (base_x + 10000.0, base_y + 0.0)
+    rect_max = (base_x + 10000.0 + length, base_y + 10000.0)
+    msp.add_lwpolyline(
+        [
+            rect_min,
+            (rect_max[0], rect_min[1]),
+            rect_max,
+            (rect_min[0], rect_max[1]),
+            rect_min,
+        ],
+        dxfattribs={"closed": True},
+    )
+
+    # Linear dimension above the rectangle.
+    # ezdxf renders DIMENSION via an anonymous block; our parser reads DIMENSION entity
+    # and uses its definition points.
+    dim = msp.add_linear_dim(
+        base=(base_x + 10000.0, base_y + 25000.0),
+        p1=p1,
+        p2=p2,
+        angle=0,
+        dimstyle="EZDXF",
+    )
+
+    # Force a predictable text format.
+    # ezdxf 1.4.x: add_linear_dim returns DimStyleOverride; use update().
+    dim.update({"dimdec": 2})
+    dim.render()
+
+    # Radial dimension for a large circle.
+    center = (base_x + 50000.0, base_y + 80000.0)
+    radius = 86020.0
+    msp.add_circle(center, radius)
+
+    rdim = msp.add_radius_dim(
+        center=center,
+        radius=radius,
+        location=(center[0] - 60000.0, center[1] + 10000.0),
+        dimstyle="EZDXF",
+    )
+    rdim.update({"dimdec": 2})
+    rdim.render()
+
+    doc.saveas(out_path)
+    print(f"Wrote {out_path}")
+
+
+if __name__ == "__main__":
+    main()

package/tools/ezdxf_regenerate_problem_fixtures.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""Regenerate a small set of DXF fixtures using ezdxf.
+
+These fixtures were previously handcrafted/minimal and ezdxf could not read them.
+Regenerating them via ezdxf makes them valid DXF fixtures and unblocks
+`yarn validate:fixtures`.
+
+This script overwrites files in test/resources.
+
+Usage:
+  ./.venv-ezdxf/bin/python tools/ezdxf_regenerate_problem_fixtures.py
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import ezdxf
+from ezdxf.lldxf.tags import Tags
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+RESOURCES_DIR = PROJECT_ROOT / "test" / "resources"
+
+
+def _write(doc: ezdxf.document.Drawing, filename: str) -> None:
+    target = RESOURCES_DIR / filename
+    target.parent.mkdir(parents=True, exist_ok=True)
+    doc.saveas(target)
+
+
+def regenerate_leader_basic() -> None:
+    doc = ezdxf.new("R2010")
+    msp = doc.modelspace()
+
+    # A simple leader with 3 vertices.
+    msp.add_leader(vertices=[(0, 0), (100, 0), (100, 50)], dimstyle="EZDXF")
+
+    _write(doc, "leader-basic.dxf")
+
+
+def regenerate_tolerance_basic() -> None:
+    doc = ezdxf.new("R2010")
+    msp = doc.modelspace()
+
+    tol = msp.new_entity(
+        "TOLERANCE",
+        {
+            "layer": "0",
+            "dimstyle": "Standard",
+            "insert": (10.0, 20.0, 0.0),
+            "content": "%%v%%v",
+            "x_axis_vector": (1.0, 0.0, 0.0),
+            "extrusion": (0.0, 0.0, 1.0),
+        },
+    )
+    # Silence unused variable warning in some linters.
+    _ = tol
+
+    _write(doc, "tolerance-basic.dxf")
+
+
+def regenerate_underlay_basic() -> None:
+    doc = ezdxf.new("R2010")
+    msp = doc.modelspace()
+
+    underlay_def = doc.objects.add_underlay_def(
+        filename="file.pdf",
+        fmt="pdf",
+        name="U1",
+    )
+
+    msp.add_underlay(
+        underlay_def=underlay_def,
+        insert=(10.0, 20.0, 0.0),
+        scale=(1.0, 1.0, 1.0),
+        rotation=0.0,
+    )
+
+    _write(doc, "underlay-basic.dxf")
+
+
+def regenerate_imagedef_basic() -> None:
+    doc = ezdxf.new("R2010")
+
+    # A standalone IMAGEDEF is still a valid fixture.
+    doc.objects.add_image_def(filename="my.png", size_in_pixel=(640, 480), name="I1")
+
+    _write(doc, "imagedef-basic.dxf")
+
+
+def regenerate_image_basic() -> None:
+    doc = ezdxf.new("R2010")
+    msp = doc.modelspace()
+
+    image_def = doc.objects.add_image_def(filename="my.png", size_in_pixel=(640, 480), name="I1")
+
+    # Place a 640x480 image at (1, 2) in drawing units.
+    msp.add_image(
+        image_def=image_def,
+        insert=(1.0, 2.0, 0.0),
+        size_in_units=(640.0, 480.0),
+        rotation=0.0,
+    )
+
+    _write(doc, "image-basic.dxf")
+
+
+def regenerate_xrecord_basic() -> None:
+    doc = ezdxf.new("R2010")
+
+    # Register under root dictionary.
+    xr = doc.rootdict.add_xrecord("TEST")
+    xr.tags = Tags([(1, "HELLO"), (40, 3.14)])
+
+    _write(doc, "xrecord-basic.dxf")
+
+
+def regenerate_block_basepoint_text_mtext_dimension() -> None:
+    doc = ezdxf.new("R2010")
+
+    blk = doc.blocks.new(name="B1", base_point=(5.0, 6.0, 0.0))
+
+    blk.add_text("Hello", dxfattribs={"height": 1.0}).set_placement((6.0, 8.0, 0.0))
+    blk.add_mtext("World", dxfattribs={"char_height": 1.0}).set_location((7.0, 9.0, 0.0))
+
+    dim = blk.add_linear_dim(
+        base=(8.0, 10.0, 0.0),
+        p1=(8.0, 10.0, 0.0),
+        p2=(12.0, 10.0, 0.0),
+        location=(8.0, 10.0, 0.0),
+        dimstyle="EZDXF",
+    )
+    dim.render()
+
+    msp = doc.modelspace()
+    msp.add_blockref("B1", insert=(100.0, 200.0, 0.0))
+
+    _write(doc, "block-basepoint-text-mtext-dimension.dxf")
+
+
+def main() -> int:
+    missing = [
+        name
+        for name in [
+            "leader-basic.dxf",
+            "tolerance-basic.dxf",
+            "underlay-basic.dxf",
+            "image-basic.dxf",
+            "imagedef-basic.dxf",
+            "xrecord-basic.dxf",
+            "block-basepoint-text-mtext-dimension.dxf",
+        ]
+        if not (RESOURCES_DIR / name).exists()
+    ]
+
+    # We still regenerate even if files are missing: this script is authoritative.
+    regenerate_leader_basic()
+    regenerate_tolerance_basic()
+    regenerate_underlay_basic()
+    regenerate_imagedef_basic()
+    regenerate_image_basic()
+    regenerate_xrecord_basic()
+    regenerate_block_basepoint_text_mtext_dimension()
+
+    if missing:
+        print("Generated missing fixtures:")
+        for name in missing:
+            print(f"- {name}")
+
+    print("Regenerated fixtures:")
+    print("- leader-basic.dxf")
+    print("- tolerance-basic.dxf")
+    print("- underlay-basic.dxf")
+    print("- imagedef-basic.dxf")
+    print("- image-basic.dxf")
+    print("- xrecord-basic.dxf")
+    print("- block-basepoint-text-mtext-dimension.dxf")
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())