compas-nest 0.1.1.dev4__tar.gz → 0.1.1.dev6__tar.gz

{compas_nest-0.1.1.dev4 → compas_nest-0.1.1.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: compas_nest
-Version: 0.1.1.dev4
+Version: 0.1.1.dev6
 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.dev6/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.dev6/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.dev4/docs/examples/07_text.md → compas_nest-0.1.1.dev6/docs/examples/08_text.md

@@ -1,11 +1,11 @@
-# 07 · Text (single-stroke font)
+# 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.
+font (e.g. for sheet-number labels). Arcs are sampled to polyline segments (adaptive, fabrication-friendly).
 
 <!-- TODO: image -->
-![text](../images/07_text.png)
+![text](../images/08_text.png)
 
 ```python
---8<-- "examples/07_text.py"
+--8<-- "examples/08_text.py"
 ```

{compas_nest-0.1.1.dev4 → compas_nest-0.1.1.dev6}/docs/examples/index.md

@@ -8,5 +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 (grid)](06_pack.md) — simple grid/array layout with `pack` (no nesting).
-7. [Text (font)](07_text.md) — single-stroke text with `text_to_polylines`.
+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.dev4/examples/06_pack.py → compas_nest-0.1.1.dev6/examples/06_pack_array.py

@@ -9,7 +9,7 @@ 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.json"
+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()
@@ -43,8 +43,8 @@ geo.add_part(
     copies=6,
 )
 
-# 2. pack into a simple grid (no nesting): 5 cells per row, 8-unit gaps
-result: nest_result = pack(geo, columns=5, gap_x=8.0, gap_y=8.0)
+# 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=1.0, gap_y=1.0)
 
 # 3. view the grid layout (elements blue)
 viewer: Viewer = Viewer()

compas_nest-0.1.1.dev6/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.dev6/examples/08_text.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+
+from compas.colors import Color
+from compas.data import json_dump
+from compas.geometry import Frame
+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. a frame to place/orient the text (origin = text origin, x-axis = reading direction)
+frame: Frame = Frame([0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0])
+
+# 2. render text to single-stroke polylines (OpenNest XML font) on that frame, 10-unit cap height
+strokes: list = text_to_polylines("compas_nest\n0 1 2 3 4 5 6 7 8 9", height=10.0, font="regular", frame=frame)
+
+# 3. view the frame and the stroke polylines (blue)
+viewer: Viewer = Viewer()
+viewer.scene.add(frame)
+for stroke in strokes:
+    viewer.scene.add(stroke, linecolor=BLUE, linewidth=2)
+viewer.show()
+
+# 4. save the polylines to JSON
+OUTPUT.parent.mkdir(parents=True, exist_ok=True)
+json_dump(strokes, OUTPUT)

{compas_nest-0.1.1.dev4 → compas_nest-0.1.1.dev6}/mkdocs.yml

@@ -48,8 +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 (grid): examples/06_pack.md
-      - 07 Text (font): examples/07_text.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.dev4 → compas_nest-0.1.1.dev6}/src/compas_nest/fonts/regular.xml

@@ -544,14 +544,11 @@
   </letter>
   <!-- DIGIT ZERO -->
   <letter code="48" start="0.1" end="0.6">
-    <path x="0.2650943396226" y="0.90283018867925">
-      <to x="0.2650943396226" y="0.09716981132075"/>
-      <to x="0.43490566037731" y="0.09716981132075"/>
-      <to x="0.43490566037731" y="0.90283018867925"/>
-      <to x="0.2650943396226" y="0.90283018867925"/>
-    </path>
-    <path x="0.15" y="0.00">
-      <to x="0.55" y="0.00" />
+    <path x="0.10" y="0.30">
+      <to x="0.55" y="0.30" b="-1.00" />
+      <to x="0.55" y="0.70" />
+      <to x="0.10" y="0.70" b="-1.00" />
+      <to x="0.10" y="0.30" />
     </path>
   </letter>
   <!-- DIGIT ONE -->
@@ -564,10 +561,10 @@
   </letter>
   <!-- DIGIT TWO -->
   <letter code="50" start="0.1" end="0.6">
-    <path x="0.55" y="0.05">
-      <to x="0.15" y="0.05" />
-      <to x="0.51891730682301" y="0.63825409294735" />
-      <to x="0.15000000000001" y="0.80" />
+    <path x="0.12" y="0.68">
+      <to x="0.54" y="0.68" b="1.00" />
+      <to x="0.10" y="0.06" />
+      <to x="0.56" y="0.06" />
     </path>
   </letter>
   <!-- DIGIT THREE -->
@@ -632,18 +629,13 @@
   </letter>
   <!-- DIGIT EIGHT -->
   <letter code="56" start="0.1" end="0.6">
-    <path x="0.2650943396" y="0.9028301887">
-      <to x="0.2650943396" y="0.5874993152" />
-      <to x="0.4349056604" y="0.4125006848" />
-      <to x="0.4349056604" y="0.0971698113" />
-      <to x="0.2650943396" y="0.0971698113" />
-      <to x="0.2650943396" y="0.4125006848"  />
-      <to x="0.4349056604" y="0.5874993152" />
-      <to x="0.4349056604" y="0.9028301887" />
-      <to x="0.2650943396" y="0.9028301887" />
+    <path x="0.11" y="0.30">
+      <to x="0.59" y="0.30" b="-1.00" />
+      <to x="0.11" y="0.30" b="-1.00" />
     </path>
-    <path x="0.15" y="0.00">
-      <to x="0.55" y="0.00" />
+    <path x="0.15" y="0.74">
+      <to x="0.55" y="0.74" b="-1.00" />
+      <to x="0.15" y="0.74" b="-1.00" />
     </path>
   </letter>
   <!-- DIGIT NINE -->

{compas_nest-0.1.1.dev4 → compas_nest-0.1.1.dev6}/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.dev4 → compas_nest-0.1.1.dev6}/src/compas_nest/result.py

@@ -3,13 +3,14 @@
 import math
 import os
 
+from compas.data import Data
 from compas.data import json_dump
 from compas.geometry import Rotation
 from compas.geometry import Translation
 
 
-class nest_result:
-    """Placements produced by a nesting engine.
+class nest_result(Data):
+    """Placements produced by a nesting engine (a serializable COMPAS ``Data``).
 
     The placement contract (shared by both engines) is::
 
@@ -30,15 +31,37 @@ class nest_result:
         Number of sheets actually used.
     fitness : float, optional
         Solver fitness (NFP engine only).
+    name : str, optional
     """
 
-    def __init__(self, placements, geo, sheet_origins, n_sheets, fitness=None):
+    def __init__(self, placements, geo, sheet_origins, n_sheets, fitness=None, name=None):
+        super().__init__(name=name)
         self.placements = placements
         self.geo = geo
         self.sheet_origins = sheet_origins
         self.n_sheets = n_sheets
         self.fitness = fitness
 
+    @property
+    def __data__(self):
+        return {
+            "placements": [dict(p) for p in self.placements],
+            "geo": self.geo,
+            "sheet_origins": [[float(o[0]), float(o[1])] for o in self.sheet_origins],
+            "n_sheets": int(self.n_sheets),
+            "fitness": self.fitness,
+        }
+
+    @classmethod
+    def __from_data__(cls, data):
+        return cls(
+            data["placements"],
+            data["geo"],
+            [tuple(o) for o in data["sheet_origins"]],
+            data["n_sheets"],
+            data.get("fitness"),
+        )
+
     @property
     def placed(self):
         """list[dict] : Placements that landed on a sheet (``sheet_id >= 0``)."""

{compas_nest-0.1.1.dev4 → compas_nest-0.1.1.dev6}/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}
@@ -82,9 +90,14 @@ def _font(name="regular"):
     return _FONTS[name]
 
 
-def text_to_polylines(text, height=1.0, font="regular", origin=(0.0, 0.0), spacing=H_SPACING):
+def text_to_polylines(text, height=1.0, font="regular", frame=None, spacing=H_SPACING):
     """Render ``text`` to a list of single-stroke :class:`compas.geometry.Polyline`.
 
+    The text is laid out on the XY plane with the first line's baseline-left at the origin, then
+    oriented/placed onto ``frame`` — so you can drop a label anywhere (e.g. on a nested sheet) with
+    any orientation. ``frame`` axes also scale: use a frame with unit axes to keep ``height`` as the
+    cap height.
+
     Parameters
     ----------
     text : str
@@ -93,23 +106,23 @@ def text_to_polylines(text, height=1.0, font="regular", origin=(0.0, 0.0), spaci
         Cap height (em) the glyphs are scaled to.
     font : str, optional
         Packaged font name: ``"regular"`` or ``"bold"``.
-    origin : tuple[float, float], optional
-        Lower-left start position of the first line.
+    frame : :class:`compas.geometry.Frame`, optional
+        Where to place/orient the text. Its origin is the text origin, its x-axis the reading
+        direction and y-axis "up". Defaults to the world XY frame.
     spacing : float, optional
         Extra gap between glyphs, in em.
 
     Returns
     -------
     list[:class:`compas.geometry.Polyline`]
-        One polyline per stroke, in the XY plane, scaled by ``height``.
+        One polyline per stroke.
     """
     glyphs = _font(font)
     fallback = glyphs.get("\0")
-    ox, oy = origin
     out = []
     for line_i, line in enumerate(text.split("\n")):
-        x = ox
-        y = oy - line_i * V_SPACING * height
+        x = 0.0
+        y = -line_i * V_SPACING * height
         for ch in line:
             glyph = glyphs.get(ch, fallback)
             if glyph is None:
@@ -119,4 +132,10 @@ def text_to_polylines(text, height=1.0, font="regular", origin=(0.0, 0.0), spaci
             for stroke in glyph["strokes"]:
                 out.append(Polyline([[x + px * height, y + py * height, 0.0] for (px, py) in stroke]))
             x += glyph["end"] * height + spacing * height
+
+    if frame is not None:
+        from compas.geometry import Transformation
+
+        matrix = Transformation.from_frame(frame)
+        out = [pl.transformed(matrix) for pl in out]
     return out

{compas_nest-0.1.1.dev4 → compas_nest-0.1.1.dev6}/tests/test_nesting.py

@@ -137,6 +137,23 @@ def test_text_to_polylines():
     assert max(len(pl.points) for pl in text_to_polylines("C", height=10.0)) > 3
 
 
+def test_result_serialization_roundtrip(geo, sheets):
+    result = opennest_collision(iterations=200, num_rotations=8, seed=1, verbose=False).solve(geo, sheets)
+    reloaded = json_loads(json_dumps(result))
+    assert type(reloaded).__name__ == "nest_result"
+    assert reloaded.n_sheets == result.n_sheets
+    assert len(reloaded.placed) == len(result.placed)
+    assert len(reloaded.placed_polylines()) == len(result.placed_polylines())  # geo survived too
+
+
+def test_text_frame_places_and_orients():
+    from compas.geometry import Frame
+
+    plain = text_to_polylines("A", height=10.0)
+    framed = text_to_polylines("A", height=10.0, frame=Frame([100, 0, 0], [1, 0, 0], [0, 1, 0]))
+    assert framed[0].points[0][0] > plain[0].points[0][0] + 90  # shifted to the frame origin
+
+
 def test_from_size_factory():
     sheets = nest_sheets.from_size(100, 50, count=2)
     assert len(sheets.sheets) == 2

compas_nest-0.1.1.dev4/docs/examples/06_pack.md

@@ -1,11 +0,0 @@
-# 06 · Pack (grid array)
-
-Lay parts out in a simple grid/array with `pack` — a deterministic layout, no nesting. It returns a
-`nest_result`, so the same `placed_polylines` / `to_json` / `to_obj` apply.
-
-<!-- TODO: image -->
-![pack](../images/06_pack.png)
-
-```python
---8<-- "examples/06_pack.py"
-```

compas_nest-0.1.1.dev4/examples/07_text.py

@@ -1,23 +0,0 @@
-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" / "07_text.json"
-
-# 1. render text to single-stroke polylines (OpenNest XML font), 10-unit cap height
-strokes: list = text_to_polylines("OpenNest\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)