Skip to content

3D modeling in Python, built for LLMs.

4.4 KB
Raw Blame
"""`export` to .obj and .stl: the meshes under the root at the current pose, in metres —
OBJ Y up, STL Z up — each closed mesh still facing out, its mirror image included."""
import struct
import tempfile
import unittest
from pathlib import Path

import sand3d as s3d
from sand3d import _core


def machine():
    s3d.empty_scene()
    cab = s3d.box("cab", 600, 600, 850)
    door = s3d.at(s3d.cylinder("door", 420, 30), on=cab.face("+X").move(z=400))
    s3d.joint("door_hinge", door, s3d.bbox(cab, "+X-Y"), axis="-Z", range=(0, 143))
    twin = s3d.transform(s3d.copy(door), mirror="y")
    return s3d.group("washer", cab, door, twin), cab, door, twin


def read_obj(path):
    """name -> (vertices, triangles), indices local to the object."""
    objects, verts, name, base = {}, [], None, 0
    for line in Path(path).read_text().splitlines():
        if line.startswith("o "):
            name = line[2:] + ("'" if line[2:] in objects else "")
            base = len(verts)
            objects[name] = ([], [])
        elif line.startswith("v "):
            verts.append(tuple(map(float, line.split()[1:])))
            objects[name][0].append(verts[-1])
        elif line.startswith("f "):
            objects[name][1].append(tuple(int(i) - 1 - base for i in line.split()[1:]))
    return objects


def read_stl(path):
    data = Path(path).read_bytes()
    n = struct.unpack("<I", data[80:84])[0]
    return [struct.unpack("<12fH", data[84 + 50 * i:84 + 50 * (i + 1)]) for i in range(n)], len(data)


def volume(tris):
    """Signed volume of closed triangles: positive when they face out."""
    total = 0.0
    for a, b, c in tris:
        total += (a[0] * (b[1] * c[2] - b[2] * c[1]) - a[1] * (b[0] * c[2] - b[2] * c[0])
                  + a[2] * (b[0] * c[1] - b[1] * c[0])) / 6
    return total


def triangles(ob):
    ob.data.calc_loop_triangles()
    return len(ob.data.loop_triangles)


class ExportMeshes(unittest.TestCase):

    def setUp(self):
        self.tmp = Path(tempfile.mkdtemp())

    def test_obj_is_the_meshes_at_the_pose_in_metres_y_up(self):
        root, cab, door, twin = machine()
        s3d.pose(door, 70)
        s3d.export(root, self.tmp / "washer.obj")
        objects = read_obj(self.tmp / "washer.obj")
        self.assertEqual(sorted(objects), ["cab", "door", "door'"])
        cab_v, cab_t = objects["cab"]
        self.assertEqual((len(cab_v), len(cab_t)), (len(cab.data.vertices), triangles(cab)))
        for axis, lo, hi in ((0, -0.3, 0.3), (1, 0.0, 0.85), (2, -0.3, 0.3)):   # Z up becomes Y up
            self.assertAlmostEqual(min(v[axis] for v in cab_v), lo, places=6)
            self.assertAlmostEqual(max(v[axis] for v in cab_v), hi, places=6)
        m = _core.world(door)
        posed = [m @ v.co for v in door.data.vertices]
        got = objects["door"][0]
        self.assertAlmostEqual(max(v[0] for v in got), max(p.x for p in posed) / 1000, places=6)
        self.assertAlmostEqual(min(v[2] for v in got), -max(p.y for p in posed) / 1000, places=6)
        for name, (vs, ts) in objects.items():
            self.assertGreater(volume([[vs[i] for i in t] for t in ts]), 0, f"{name} faces in")

    def test_stl_is_binary_triangles_z_up(self):
        root, cab, door, twin = machine()
        s3d.export(root, self.tmp / "washer.stl")
        rows, size = read_stl(self.tmp / "washer.stl")
        self.assertEqual(len(rows), sum(triangles(ob) for ob in (cab, door, twin)))
        self.assertEqual(size, 84 + 50 * len(rows))
        corners = [r[3 + 3 * k:6 + 3 * k] for r in rows for k in range(3)]
        world = [_core.world(ob) @ v.co for ob in (cab, door, twin) for v in ob.data.vertices]
        for axis in range(3):                                   # Z stays up
            self.assertAlmostEqual(min(c[axis] for c in corners), min(p[axis] for p in world) / 1000, places=6)
            self.assertAlmostEqual(max(c[axis] for c in corners), max(p[axis] for p in world) / 1000, places=6)
        self.assertGreater(volume([(r[3:6], r[6:9], r[9:12]) for r in rows]), 0)

    def test_the_unit_becomes_metres(self):
        s3d.empty_scene()
        s3d.units("cm")
        try:
            root = s3d.group("thing", s3d.box("b", 1, 1, 1))
            s3d.export(root, self.tmp / "thing.obj")
            vs = read_obj(self.tmp / "thing.obj")["b"][0]
            self.assertAlmostEqual(max(v[0] for v in vs) - min(v[0] for v in vs), 0.01, places=9)
        finally:
            s3d.empty_scene()
            s3d.units("mm")


if __name__ == "__main__":
    unittest.main()