compas-nest 0.1.1.dev3__tar.gz → 0.1.1.dev5__tar.gz

{compas_nest-0.1.1.dev3 → compas_nest-0.1.1.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: compas_nest
-Version: 0.1.1.dev3
+Version: 0.1.1.dev5
 Summary: 2D irregular nesting (OpenNest) for COMPAS.
 Author-Email: Petras Vestartas <petrasvestartas@gmail.com>
 Classifier: License :: OSI Approved :: MIT License

compas_nest-0.1.1.dev5/docs/examples/06_pack_array.md

@@ -0,0 +1,12 @@
+# 06 · Pack (array)
+
+Lay parts out in a simple **array** with `pack` — a fixed number of elements per row, wrapping to the
+next row. Deterministic, no nesting; returns a `nest_result`, so `placed_polylines` / `to_json` /
+`to_obj` apply.
+
+<!-- TODO: image -->
+![pack array](../images/06_pack_array.png)
+
+```python
+--8<-- "examples/06_pack_array.py"
+```

compas_nest-0.1.1.dev5/docs/examples/07_pack_distance.md

@@ -0,0 +1,11 @@
+# 07 · Pack (distance)
+
+Pack parts by **row width** with `pack(..., max_width=...)`: a row fills up to the given distance,
+then the next element wraps to a new row.
+
+<!-- TODO: image -->
+![pack distance](../images/07_pack_distance.png)
+
+```python
+--8<-- "examples/07_pack_distance.py"
+```

compas_nest-0.1.1.dev5/docs/examples/08_text.md

@@ -0,0 +1,11 @@
+# 08 · Text (single-stroke font)
+
+Render text to single-stroke polylines with `text_to_polylines`, using the OpenNest XML engraving
+font (e.g. for sheet-number labels). Arcs are sampled to polyline segments (adaptive, fabrication-friendly).
+
+<!-- TODO: image -->
+![text](../images/08_text.png)
+
+```python
+--8<-- "examples/08_text.py"
+```

{compas_nest-0.1.1.dev3 → compas_nest-0.1.1.dev5}/docs/examples/index.md

@@ -8,3 +8,6 @@ placed geometry to `data/output/` as JSON (full result) and OBJ (outlines + hole
 3. [Live animation (NFP)](03_nfp_animated.md) — watch the GA layout evolve.
 4. [Clearance offset](04_collision_dataset.md) — add gaps with `offset_geo` / `offset_sheets`.
 5. [Attributes](05_attributes.md) — carry geometry (a centroid point) through placement.
+6. [Pack (array)](06_pack_array.md) — fixed number of elements per row with `pack`.
+7. [Pack (distance)](07_pack_distance.md) — wrap by row width with `pack(max_width=...)`.
+8. [Text (font)](08_text.md) — single-stroke text with `text_to_polylines`.

compas_nest-0.1.1.dev5/examples/06_pack_array.py

@@ -0,0 +1,60 @@
+from pathlib import Path
+
+from compas.colors import Color
+from compas.geometry import Polyline
+from compas_viewer import Viewer
+
+from compas_nest import nest_geo
+from compas_nest import nest_result
+from compas_nest import pack
+
+BLUE: Color = Color.from_hex("#0072B2")
+OUTPUT: Path = Path(__file__).parent.parent / "data" / "output" / "06_pack_array.json"
+
+# 1. parts (one with a hole) with several copies each
+geo: nest_geo = nest_geo()
+geo.add_part(
+    Polyline([
+        [0, 0, 0],
+        [30, 0, 0],
+        [30, 12, 0],
+        [0, 12, 0],
+        [0, 0, 0],
+    ]),
+    copies=6,
+)
+geo.add_part(
+    Polyline([
+        [0, 0, 0],
+        [20, 0, 0],
+        [20, 20, 0],
+        [0, 20, 0],
+        [0, 0, 0],
+    ]),
+    holes=[
+        Polyline([
+            [6, 6, 0],
+            [14, 6, 0],
+            [14, 14, 0],
+            [6, 14, 0],
+            [6, 6, 0],
+        ]),
+    ],
+    copies=6,
+)
+
+# 2. pack into an array: a fixed number of elements per row (5), wrapping to the next row
+result: nest_result = pack(geo, columns=5, gap_x=0.0, gap_y=0.0)
+
+# 3. view the grid layout (elements blue)
+viewer: Viewer = Viewer()
+for group in result.placed_polylines():
+    for part in group["parts"]:
+        viewer.scene.add(part["outline"], linecolor=BLUE, linewidth=2)
+        for hole in part["holes"]:
+            viewer.scene.add(hole, linecolor=BLUE)
+viewer.show()
+
+# 4. save the placed geometry to JSON (full result) and OBJ (outlines + holes)
+result.to_json(OUTPUT)
+result.to_obj(OUTPUT.with_suffix(".obj"))

compas_nest-0.1.1.dev5/examples/07_pack_distance.py

@@ -0,0 +1,60 @@
+from pathlib import Path
+
+from compas.colors import Color
+from compas.geometry import Polyline
+from compas_viewer import Viewer
+
+from compas_nest import nest_geo
+from compas_nest import nest_result
+from compas_nest import pack
+
+BLUE: Color = Color.from_hex("#0072B2")
+OUTPUT: Path = Path(__file__).parent.parent / "data" / "output" / "07_pack_distance.json"
+
+# 1. parts (one with a hole) with several copies each
+geo: nest_geo = nest_geo()
+geo.add_part(
+    Polyline([
+        [0, 0, 0],
+        [30, 0, 0],
+        [30, 12, 0],
+        [0, 12, 0],
+        [0, 0, 0],
+    ]),
+    copies=6,
+)
+geo.add_part(
+    Polyline([
+        [0, 0, 0],
+        [20, 0, 0],
+        [20, 20, 0],
+        [0, 20, 0],
+        [0, 0, 0],
+    ]),
+    holes=[
+        Polyline([
+            [6, 6, 0],
+            [14, 6, 0],
+            [14, 14, 0],
+            [6, 14, 0],
+            [6, 6, 0],
+        ]),
+    ],
+    copies=6,
+)
+
+# 2. pack by distance: fill a row up to max_width, then wrap to the next row
+result: nest_result = pack(geo, max_width=120.0, gap_x=5.0, gap_y=5.0)
+
+# 3. view the layout (elements blue)
+viewer: Viewer = Viewer()
+for group in result.placed_polylines():
+    for part in group["parts"]:
+        viewer.scene.add(part["outline"], linecolor=BLUE, linewidth=2)
+        for hole in part["holes"]:
+            viewer.scene.add(hole, linecolor=BLUE)
+viewer.show()
+
+# 4. save the placed geometry to JSON (full result) and OBJ (outlines + holes)
+result.to_json(OUTPUT)
+result.to_obj(OUTPUT.with_suffix(".obj"))

compas_nest-0.1.1.dev5/examples/08_text.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+
+from compas.colors import Color
+from compas.data import json_dump
+from compas_viewer import Viewer
+
+from compas_nest import text_to_polylines
+
+BLUE: Color = Color.from_hex("#0072B2")
+OUTPUT: Path = Path(__file__).parent.parent / "data" / "output" / "08_text.json"
+
+# 1. render text to single-stroke polylines (OpenNest XML font), 10-unit cap height
+strokes: list = text_to_polylines("compas_nest\n0 1 2", height=10.0, font="regular")
+
+# 2. view the stroke polylines (blue)
+viewer: Viewer = Viewer()
+for stroke in strokes:
+    viewer.scene.add(stroke, linecolor=BLUE, linewidth=2)
+viewer.show()
+
+# 3. save the polylines to JSON
+OUTPUT.parent.mkdir(parents=True, exist_ok=True)
+json_dump(strokes, OUTPUT)

{compas_nest-0.1.1.dev3 → compas_nest-0.1.1.dev5}/mkdocs.yml

@@ -48,6 +48,9 @@ nav:
       - 03 Live animation (NFP): examples/03_nfp_animated.md
       - 04 Clearance offset: examples/04_collision_dataset.md
       - 05 Attributes: examples/05_attributes.md
+      - 06 Pack (array): examples/06_pack_array.md
+      - 07 Pack (distance): examples/07_pack_distance.md
+      - 08 Text (font): examples/08_text.md
   - API Reference:
       - api/index.md
       - Data structures: api/compas_nest.datastructures.md

{compas_nest-0.1.1.dev3 → compas_nest-0.1.1.dev5}/src/compas_nest/pack.py

@@ -15,20 +15,26 @@ def _bbox(polyline):
     return min(xs), min(ys), max(xs), max(ys)
 
 
-def pack(geo, columns=10, gap_x=10.0, gap_y=10.0):
+def pack(geo, columns=10, gap_x=10.0, gap_y=10.0, max_width=None):
     """Lay parts out in a simple row-major grid (no nesting).
 
-    Each part instance (``copies`` expanded) is placed in a cell; rows wrap every ``columns`` items.
-    The x-advance uses each part's own width; the row height is the tallest part in that row.
+    Each part instance (``copies`` expanded) is placed left to right; the x-advance uses each part's
+    own width and the row height is the tallest part in that row. Two wrapping modes:
+
+    * **array** (default) — start a new row every ``columns`` items.
+    * **distance** — pass ``max_width`` and a row wraps once the next part would exceed that width
+      (``columns`` is ignored). A part wider than ``max_width`` still gets its own row.
 
     Parameters
     ----------
     geo : :class:`compas_nest.nest_geo`
         The parts to arrange (holes and attributes are carried along).
     columns : int, optional
-        Number of cells per row before wrapping.
+        Number of cells per row before wrapping (array mode).
     gap_x, gap_y : float, optional
         Gaps between cells horizontally and vertically.
+    max_width : float, optional
+        If set, wrap by row width instead of by ``columns`` (distance mode).
 
     Returns
     -------
@@ -48,6 +54,12 @@ def pack(geo, columns=10, gap_x=10.0, gap_y=10.0):
         w = maxx - minx
         h = maxy - miny
         for _ in range(copies):
+            # distance mode: wrap before placing if this part would overflow the row
+            if max_width is not None and col > 0 and (x + w) > max_width:
+                col = 0
+                x = 0.0
+                y += row_h + gap_y
+                row_h = 0.0
             placements.append(
                 {
                     "part_index": part_index,
@@ -60,7 +72,8 @@ def pack(geo, columns=10, gap_x=10.0, gap_y=10.0):
             x += w + gap_x
             row_h = max(row_h, h)
             col += 1
-            if col >= columns:
+            # array mode: wrap after a fixed number of columns
+            if max_width is None and col >= columns:
                 col = 0
                 x = 0.0
                 y += row_h + gap_y

{compas_nest-0.1.1.dev3 → compas_nest-0.1.1.dev5}/src/compas_nest/text.py

@@ -14,13 +14,20 @@ from compas.geometry import Polyline
 
 H_SPACING = 0.1  # gap between glyphs, in em (matches OpenNest)
 V_SPACING = 1.4  # line height, in em
-_ARC_SEGMENTS = 10  # straight segments per bulge-arc
+# Arcs are emitted as straight segments (good for fabrication). Sampling is adaptive: roughly one
+# segment per ARC_STEP of sweep, so gentle curves stay light and tight curves get enough points.
+ARC_STEP = math.radians(15.0)  # max angle per segment
+_ARC_MIN = 2  # at least this many segments per arc
 
 _FONTS = {}  # name -> {char: glyph}
 
 
-def _arc_points(p1, tangent, p2, segments):
-    """Sample an arc that starts at p1 with the given start tangent and ends at p2 (excludes p1)."""
+def _arc_points(p1, tangent, p2):
+    """Sample an arc that starts at p1 with the given start tangent and ends at p2 (excludes p1).
+
+    The number of straight segments is chosen from the swept angle (~one per :data:`ARC_STEP`),
+    keeping the point count minimal while staying close to the true arc.
+    """
     x1, y1 = p1
     x2, y2 = p2
     tx, ty = tangent
@@ -43,6 +50,7 @@ def _arc_points(p1, tangent, p2, segments):
         sweep = (a2 - a1) % (2 * math.pi)
     else:
         sweep = -((a1 - a2) % (2 * math.pi))
+    segments = max(_ARC_MIN, int(math.ceil(abs(sweep) / ARC_STEP)))
     return [(cx + r * math.cos(a1 + sweep * i / segments), cy + r * math.sin(a1 + sweep * i / segments)) for i in range(1, segments + 1)]
 
 
@@ -64,7 +72,7 @@ def _parse_glyph(letter):
                 cs, sn = math.cos(d2), math.sin(d2)
                 chx, chy = tox - lx, toy - ly
                 tangent = (chx * cs - chy * sn, chx * sn + chy * cs)
-                pts.extend(_arc_points((lx, ly), tangent, (tox, toy), _ARC_SEGMENTS))
+                pts.extend(_arc_points((lx, ly), tangent, (tox, toy)))
             lx, ly = tox, toy
         strokes.append(pts)
     return {"start": start, "end": end, "strokes": strokes}