yapCAD 0.3.0__py2.py3-none-any.whl → 0.3.1__py2.py3-none-any.whl

yapcad/triangulator.py

@@ -0,0 +1,103 @@
+"""Triangulation helpers for yapCAD surfaces.
+
+We delegate to ``mapbox-earcut`` (the fast ear clipping implementation
+used by Mapbox GL) to keep the logic compact and reliable.  The helper
+routine in this file simply normalises yapCAD polygon inputs into the
+format expected by earcut and converts the resulting indices back into
+triangle vertex tuples.
+"""
+
+from __future__ import annotations
+
+from typing import Iterable, List, Sequence, Tuple
+
+import numpy as np
+
+try:
+    import mapbox_earcut as _earcut
+except ImportError as exc:  # pragma: no cover - import guard
+    raise ImportError(
+        "mapbox-earcut must be installed to triangulate polygons with holes"
+    ) from exc
+
+from yapcad.geom import epsilon
+
+Point2D = Tuple[float, float]
+
+
+def triangulate_polygon(outer: Sequence[Sequence[float]],
+                        holes: Iterable[Sequence[Sequence[float]]] | None = None
+                        ) -> List[List[Point2D]]:
+    """Return triangles covering ``outer`` minus any ``holes``.
+
+    ``outer`` and each entry in ``holes`` is expected to be a sequence of
+    XY-like points.  Degenerate loops (fewer than three distinct points)
+    are ignored.  The returned triangles are lists of three ``(x, y)``
+    pairs.  Downstream code is responsible for lifting the coordinates
+    into 3D and enforcing winding to match the target surface normal.
+    """
+
+    if holes is None:
+        holes = []
+
+    outer_loop = _prepare_loop(outer, want_ccw=True)
+    if len(outer_loop) < 3:
+        return []
+
+    point_map: List[Point2D] = []
+
+    ring_ends: List[int] = []
+
+    def _append(loop: Sequence[Point2D]) -> None:
+        for x, y in loop:
+            point_map.append((x, y))
+        ring_ends.append(len(point_map))
+
+    _append(outer_loop)
+
+    for hole in holes:
+        loop = _prepare_loop(hole, want_ccw=False)
+        if len(loop) < 3:
+            continue
+        _append(loop)
+
+    vertices = np.asarray(point_map, dtype=np.float32)
+    ring_array = np.asarray(ring_ends, dtype=np.uint32)
+    indices = _earcut.triangulate_float32(vertices, ring_array)
+    triangles: List[List[Point2D]] = []
+    for i in range(0, len(indices), 3):
+        triangles.append([point_map[indices[i]],
+                          point_map[indices[i + 1]],
+                          point_map[indices[i + 2]]])
+    return triangles
+
+
+def _prepare_loop(points: Sequence[Sequence[float]], *, want_ccw: bool) -> List[Point2D]:
+    loop: List[Point2D] = []
+    for pt in points:
+        x, y = float(pt[0]), float(pt[1])
+        if loop and _near(loop[-1], (x, y)):
+            continue
+        loop.append((x, y))
+    if loop and _near(loop[0], loop[-1]):
+        loop.pop()
+    if len(loop) < 3:
+        return loop
+    area = _signed_area(loop)
+    if want_ccw and area < 0:
+        loop.reverse()
+    elif not want_ccw and area > 0:
+        loop.reverse()
+    return loop
+
+
+def _near(p1: Point2D, p2: Point2D) -> bool:
+    return abs(p1[0] - p2[0]) <= epsilon and abs(p1[1] - p2[1]) <= epsilon
+
+
+def _signed_area(loop: Sequence[Point2D]) -> float:
+    total = 0.0
+    for i, (x0, y0) in enumerate(loop):
+        x1, y1 = loop[(i + 1) % len(loop)]
+        total += x0 * y1 - x1 * y0
+    return total / 2.0

yapcad/xform.py

@@ -44,7 +44,6 @@ import yapcad.geom as geom
 
 ## FIXME: only one class is defined for now
 
-
 class Matrix:
     """4x4 transformation matrix class for transforming homogemenous 3D coordinates"""
 

{yapcad-0.3.0.dist-info → yapcad-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yapCAD
-Version: 0.3.0
+Version: 0.3.1
 Summary: yet another procedural CAD and computational geometry system
 Author-email: Richard DeVaul <richard.devaul@gmail.com>
 Project-URL: Homepage, https://github.com/rdevaul/yapCAD/
@@ -28,12 +28,12 @@ Dynamic: license-file
 ==========
 
 yet another procedural CAD and computational geometry system written in
-python 3
+python 3, now with a growing focus on 3D generative design and STL export
 
-.. figure:: images/yapCadSplash.png
-   :alt: **yapCAD** image
+.. figure:: images/RocketDemoScreenshot.png
+   :alt: **yapCAD** rocket example
 
-   **yapCAD** image
+   **yapCAD** rocket example
 
 what’s **yapCAD** for?
 ----------------------
@@ -42,8 +42,10 @@ First and foremost, **yapCAD** is a framework for creating
 `parametric <https://en.wikipedia.org/wiki/Parametric_design>`__,
 procedural, and
 `generative <https://en.wikipedia.org/wiki/Parametric_design>`__ design
-systems. You can also use **yapCAD** for other CAD, CAM, and
-computational geometry purposes.
+systems. Starting with the 0.5 release, the emphasis has shifted toward
+3D solid workflows, including STL export for downstream slicing and
+simulation, while retaining support for DXF generation and computational
+geometry experiments.
 
 software status
 ---------------
@@ -84,28 +86,23 @@ clone the github repository as shown above, and make sure that your
 PYTHONPATH includes the cloned top-level ``yapCAD`` directory. You will
 find the examples in the ``yapCAD/examples`` directory.
 
-For a fully worked parametric design system, see the ``boxcut`` example.
+For a fully worked 2D parametric design system, see the ``boxcut`` example.
+For a 3D generative example that builds a multi-stage rocket, visualises
+it, and exports STL, see ``examples/rocket_demo.py``.
 
 documentation
 ~~~~~~~~~~~~~
 
 Online **yapCAD** documentation can be found here:
-https://yapcad.readthedocs.io/en/latest/ — for some reason
-``readthedocs.io`` isn’t generating the full module documentation, so
-you might want to build a local copy, as described below.
+https://yapcad.readthedocs.io/en/latest/ — some module references lag
+behind the latest 3D-focused APIs, so you may want to build a local copy
+as described below to explore ``geometry_utils``, ``geometry_checks``,
+``metadata``, and ``io.stl``.
 
-To build the HTML **yapCAD** documentation locally, first make sure you
-have the sphinx package installed:
-
-::
-
-   pip install sphinx --user
-
-Then clone the github repository as shown above, ``cd`` to the
-``yapCAD`` directory, and type
-
-::
+To build the HTML **yapCAD** documentation locally, install the
+documentation dependencies and run Sphinx from the project root::
 
+   python3 -m pip install -r docs/requirements.txt
    make -C docs html
 
 This will build the HTML documents in the ``build/sphinx/html``
@@ -117,29 +114,77 @@ information.
 running tests
 ~~~~~~~~~~~~~
 
-The repository includes a small pytest suite that exercises the core
-geometry primitives. Install the testing dependencies and run pytest
-from the project root with the source tree on ``PYTHONPATH``::
+The repository includes a comprehensive pytest suite that exercises both core
+geometry primitives and visual rendering capabilities. First, set up the
+testing environment::
 
-   python3 -m pip install pytest pytest-cov
-   PYTHONPATH=./src python3 -m pytest
+   # Create and activate virtual environment
+   pyenv local 3.12  # or use python3.12 directly
+   python3 -m venv v_312
+   source v_312/bin/activate
 
-The default configuration enables coverage reporting via
-``pytest-cov``. If you prefer to skip coverage, you can override the
-options::
+   # Install dependencies
+   pip install -r requirements.txt
+   pip install pytest pytest-cov
 
-   PYTHONPATH=./src python3 -m pytest --override-ini addopts=
+Non-Visual Tests (Automated/CI-friendly)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Run the core computational geometry tests (including triangle, metadata,
+validation, and STL exporter checks) without interactive displays::
+
+   # Run all non-visual tests
+   PYTHONPATH=./src pytest tests/ -m "not visual"
+
+   # With coverage reporting (default)
+   PYTHONPATH=./src pytest tests/ -m "not visual" --cov=src
+
+   # Skip coverage for faster execution
+   PYTHONPATH=./src pytest tests/ -m "not visual" --override-ini addopts=
+
+Visual Tests (Interactive)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+yapCAD includes visual tests that create interactive 3D renderings to verify
+geometry generation and display functionality (for example,
+``tests/test_mesh_view.py::test_mesh_view_visual_normals``). These require a
+display and user interaction::
+
+   # Run all visual tests (opens interactive windows)
+   ./run_visual_tests_venv.sh
+
+   # Run specific visual tests by pattern
+   ./run_visual_tests_venv.sh test_geom      # Only test_geom* visual tests
+   ./run_visual_tests_venv.sh surface        # Tests matching "surface"
+   ./run_visual_tests_venv.sh Face           # Face-related tests
+
+   # Alternative: Manual pytest execution
+   VISUALTEST=true PYTHONPATH=./src pytest tests/ -m visual
+
+   # Or run individual visual tests
+   VISUALTEST=true PYTHONPATH=./src pytest tests/test_geom3d.py::TestSurface::test_surface -s
+
+**Note:** Visual tests require closing each interactive window to proceed to the next test. Use the dedicated ``run_visual_tests_venv.sh`` script for the best experience, as it runs each test in an isolated subprocess to prevent early termination.
 
 **yapCAD** goals
 ----------------
 
 The purpose of **yapCAD** is to support 2D and 3D computational geometry
 and parametric, procedural, and generative design projects in python3.
-**yapCAD** is designed to support multiple rendering back-ends, such
-that a relatively small amount of code is necessary to add support for a
-2D or 3D cad or drawing file format. At present, **yapCAD** supports the
-AutoCad DXF file format for creating two-dimensional drawings and OpenGL
-for creating interactive 2D and 3D renderings.
+**yapCAD** is designed to support multiple rendering back-ends, such that
+only a small amount of code is necessary to add support for a CAD or
+drawing file format. At present, **yapCAD** supports:
+
+* AutoCAD DXF output for two-dimensional drawings (via
+  `ezdxf <https://github.com/mozman/ezdxf>`__).
+* STL export for 3D solids (via the new ``yapcad.io.stl`` module).
+* OpenGL visualisation for 2D/3D geometries using
+  `pyglet <https://github.com/pyglet/pyglet>`__.
+
+The 0.5.0 release lays the shared foundations (triangle utilities,
+metadata, validation checks, and STL export) that pave the way toward STEP
+support and a packaged, provenance-aware project model targeted for the
+forthcoming 1.0 release.
 
 The foundations of **yapCAD** are grounded in decades of the author’s
 experience with graphics system programming, 3D CAD and simulation.
@@ -158,8 +203,8 @@ package, and interactive OpenGL visualization using the amazing
 
 (for a more complete list, see the `examples folder <./examples/>`__)
 
-It’s pretty easy to make a DXF drawing with **yapCAD**. Here is an
-example:
+It’s pretty easy to make a DXF drawing or a 3D model with **yapCAD**. Here
+is a DXF example:
 
 ::
 
@@ -194,6 +239,15 @@ example:
    # write out the geometry as example1-out.dxf
    dd.display()
 
+For a 3D example that generates a complete rocket assembly and exports
+STL::
+
+   from pathlib import Path
+   from examples.rocket_demo import build_rocket, export_stl
+
+   components, assembly = build_rocket()
+   export_stl(assembly, Path("rocket_demo.stl"))
+
 The **yapCAD** system isn’t just about rendering, of course, it’s about
 computational geometry. For example, if you want to calculate the
 intersection of lines and arcs in a plane, we have you covered:

yapcad-0.3.1.dist-info/RECORD

@@ -0,0 +1,27 @@
+yapcad/__init__.py,sha256=CUEd7EOL-ne31ggDprsi4lwLWMV1SRV5KYqkuDTdxrQ,400
+yapcad/combine.py,sha256=WhI3D9lSZFzu1HD68HGUTbNNrJsT4SeCl1MOcjxsa1k,2932
+yapcad/drawable.py,sha256=kPYbIhOD5MesmRSeXTiFJoE1UwVQWekoeu19athfH7Y,15843
+yapcad/ezdxf_drawable.py,sha256=o6Rei044ROkaniHZJwyBGtahaD3BU1927-AkFpPzqwE,5966
+yapcad/geom.py,sha256=bg_ayg1aovT17HwgFwoJ7HbvI2InEjii9Bvr8PoZ04g,105604
+yapcad/geom3d.py,sha256=c6MleS-AiCWdju_mtPzUd7vhzkoT5nlJvoz7yimwdwU,33415
+yapcad/geom3d_util.py,sha256=O-LUVqk2-BmFb-g-2ex44vHwKK_U4xCfqMY5Cevbvi8,15663
+yapcad/geom_util.py,sha256=GMfgCyXuv9J4mdOfkqxNZT7EZZFEMV_ZpVTfuol8ve8,26370
+yapcad/geometry.py,sha256=FcIF94a_usw04C0RDJDRDCCi44eya7lyahlU1Vw9wXM,16145
+yapcad/geometry_checks.py,sha256=ABI0t5kls2HAidyyPp_EdoVqPxJAEtCWysPKvCeSK3s,2975
+yapcad/geometry_utils.py,sha256=N_073tEV08AKjJRTeuNJMPjPgonFPUeiuh_jY7Xx7mA,3438
+yapcad/mesh.py,sha256=QmPMeqdToyLztPupY8vSHQfrUz3UEBH1p8Pa9XFVPCg,1329
+yapcad/metadata.py,sha256=6foSa_4N9-PO4kL8YchbXboXZZFjEcUSG6F1spwGCVE,3096
+yapcad/octtree.py,sha256=MxyNMgozeLUBK5cC5_IC_9fK4BqSg4VeoKP389AUVmM,19793
+yapcad/poly.py,sha256=y5cSiCbA-pCbkO5zIa9kVk2_00w7FkWxY380nK14wt4,16549
+yapcad/pyglet_drawable.py,sha256=etgul99FOywq3rXf9uNu6cd59cECe4OMYX_ht5BcyMw,38424
+yapcad/triangulator.py,sha256=hwxoxb564wZRYPEYbGiD-SDPu_x_SueYha0Kjmnu3Bo,3210
+yapcad/xform.py,sha256=Qy_KYqbTcmspmKZfo-OGU_1Z3XRpL7p5buwc5uAzlvo,9537
+yapcad/io/__init__.py,sha256=EDwSGx-0na9fZabaK57zrq3GwEtkwN5Vo_pTS-ZtuXQ,85
+yapcad/io/stl.py,sha256=HNICfPz_CXYIbTP7d4spdSkMdmrt3d825MNzYA9ah9w,2596
+yapcad-0.3.1.dist-info/licenses/AUTHORS.rst,sha256=JzvJA3p1aSIOTaaB3aCtB-ZrUQrVm869gdROUV5bRh8,84
+yapcad-0.3.1.dist-info/licenses/LICENSE,sha256=NkGvciCD5MEHmCtnivAi2PqcEhBYAkSAarP-bWAoknM,1071
+yapcad-0.3.1.dist-info/licenses/LICENSE.txt,sha256=FyT_Hxn5USuJ1Mu3-4Ou4T2x-Dzfiy06ZOnWkfdJ33o,1081
+yapcad-0.3.1.dist-info/METADATA,sha256=HBc4tviyXQPUCGdA3-nueViX7QVaBaNHM7YGbVEqOWU,21588
+yapcad-0.3.1.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+yapcad-0.3.1.dist-info/top_level.txt,sha256=NAtnfsyeALrvhI63FGS3_TEUh26OKRvnm1_lCOOgjKA,7
+yapcad-0.3.1.dist-info/RECORD,,

yapcad-0.3.0.dist-info/RECORD

@@ -1,17 +0,0 @@
-yapcad/__init__.py,sha256=CUEd7EOL-ne31ggDprsi4lwLWMV1SRV5KYqkuDTdxrQ,400
-yapcad/combine.py,sha256=uC8QsFRGa198rIkKhNIOm-GhuDvezlGcX3nhEY2N2YE,13993
-yapcad/drawable.py,sha256=RKG8emMC0E6__-L89zrBVxAB1JiFUPA51cAweCu7zP8,14605
-yapcad/ezdxf_drawable.py,sha256=pZGLS9Dw108GG6ItahszSkkRopYLtgP9CDVWxHCrMrs,5948
-yapcad/geom.py,sha256=YSqG-C7Ti9VCkSyIC3VggJImx_tAlyxtN38SNUdGM5Q,108843
-yapcad/geom3d.py,sha256=W6gmo8UifgFwy3HHQvgvvgp96l2ahMqTVyTmbXqNEd8,2865
-yapcad/geometry.py,sha256=H-ahJG2nsXvV__6TqWf_ReRWVFZdL4bBPPPTYEnPvi0,2564
-yapcad/poly.py,sha256=Fku0ynBzYUSb5UZA6WY0yLPmDTc_Eg6BVE3DUKqiJqo,21447
-yapcad/pyglet_drawable.py,sha256=dV9dcwzZRlPwhx18Dv0CX7wQOCxnxwk4Si_FL9heNs8,18475
-yapcad/xform.py,sha256=It95Ql9JpMFqk95X8MvAmqYpCQu0VKp-JShmRTC0Ztk,9538
-yapcad-0.3.0.dist-info/licenses/AUTHORS.rst,sha256=JzvJA3p1aSIOTaaB3aCtB-ZrUQrVm869gdROUV5bRh8,84
-yapcad-0.3.0.dist-info/licenses/LICENSE,sha256=NkGvciCD5MEHmCtnivAi2PqcEhBYAkSAarP-bWAoknM,1071
-yapcad-0.3.0.dist-info/licenses/LICENSE.txt,sha256=FyT_Hxn5USuJ1Mu3-4Ou4T2x-Dzfiy06ZOnWkfdJ33o,1081
-yapcad-0.3.0.dist-info/METADATA,sha256=zfvxqcMOeJJsH2yp5Mw4TJkGeuyIAbeQ507n4f7PTdY,18999
-yapcad-0.3.0.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
-yapcad-0.3.0.dist-info/top_level.txt,sha256=NAtnfsyeALrvhI63FGS3_TEUh26OKRvnm1_lCOOgjKA,7
-yapcad-0.3.0.dist-info/RECORD,,