File size: 6,572 Bytes
c941945 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 | # Copyright (c) 2026, dishsim project.
#
# SPDX-License-Identifier: BSD-3-Clause
"""Procedural dishware props (Kit-free): tumbler, wine glass, container + lid, serving spoon.
Each builder returns a list of **convex, watertight** trimesh pieces in the object's canonical
frame (Z-up for drinkware/containers, length-along-X for utensils, origin at the bbox center).
The pieces serve two consumers with zero decomposition slop:
- The authoring pipeline (``build_object_assets.py``, in git history) authored them as per-part
USD mesh prims, each with a convex-hull collider (PhysX side);
- ``code/initialization/bosch/decompose_meshes.py`` writes them verbatim as the FCL pieces (no CoACD — CoACD
would seal thin open shells like the glass walls).
Deterministic by construction (fixed segment counts, no RNG): code/initialization/bosch/decompose_meshes.py must regenerate
byte-identical geometry from the registry dims alone. Dims come from
:data:`dishsim.config.OBJECTS` — edit there, not here.
"""
import numpy as np
import trimesh
from dishsim import config
#: radial segments for shell walls (each wall segment is one convex piece)
WALL_SEGMENTS = 12
#: polygon segments for solid lathe pieces (discs, stems)
SOLID_SIDES = 24
def _ring_wall(
r_in_bot: float,
r_out_bot: float,
r_in_top: float,
r_out_top: float,
z_bot: float,
z_top: float,
segments: int = WALL_SEGMENTS,
) -> list[trimesh.Trimesh]:
"""An open conical shell wall as ``segments`` convex hull pieces (arc slabs)."""
parts = []
ang = np.linspace(0.0, 2.0 * np.pi, segments + 1)
# sub-sample each arc so the hull follows the curve (3 points per arc face)
for i in range(segments):
a = np.linspace(ang[i], ang[i + 1], 4)
ca, sa = np.cos(a), np.sin(a)
pts = []
for r, z in ((r_in_bot, z_bot), (r_out_bot, z_bot), (r_in_top, z_top), (r_out_top, z_top)):
pts.append(np.column_stack([r * ca, r * sa, np.full_like(a, z)]))
hull = trimesh.convex.convex_hull(np.vstack(pts))
parts.append(hull)
return parts
def _disc(r: float, z_bot: float, z_top: float, sides: int = SOLID_SIDES) -> trimesh.Trimesh:
"""A solid cylinder (convex) between two z planes."""
m = trimesh.creation.cylinder(radius=r, height=z_top - z_bot, sections=sides)
m.apply_translation([0.0, 0.0, (z_bot + z_top) / 2.0])
return m
def _box(size, center) -> trimesh.Trimesh:
m = trimesh.creation.box(extents=size)
m.apply_translation(center)
return m
def tumbler() -> list[trimesh.Trimesh]:
"""Open drinking tumbler: tapered shell, dia 52 -> 60 mm, h 105 mm, wall 2.5 mm."""
spec = config.OBJECTS["tumbler"]
h = spec.height_m
r_top = spec.rim_radius_m
r_bot = 0.026
wall = 0.0025
floor_t = 0.004
z0, z1 = -h / 2.0, h / 2.0
parts = [_disc(r_bot, z0, z0 + floor_t)]
parts += _ring_wall(r_bot - wall, r_bot, r_top - wall, r_top, z0 + floor_t, z1)
return parts
def wine_glass() -> list[trimesh.Trimesh]:
"""Wine glass: foot disc + stem + open tulip bowl; h 120 mm, bowl dia 58 mm.
The stem is 8 mm to seat in the upper rack's stemware scallops (r 8 mm).
"""
spec = config.OBJECTS["wine_glass"]
h = spec.height_m
r_bowl = spec.rim_radius_m
z0 = -h / 2.0
foot_t = 0.004
stem_h = 0.046
stem_r = 0.004
bowl_h = h - foot_t - stem_h # 0.070
wall = 0.002
parts = [
_disc(0.0275, z0, z0 + foot_t), # foot
_disc(stem_r, z0 + foot_t, z0 + foot_t + stem_h), # stem
_disc(0.012, z0 + foot_t + stem_h, z0 + foot_t + stem_h + 0.008), # bowl base cap
]
zb0 = z0 + foot_t + stem_h
# tulip profile: radius widens then eases at the rim (3 stacked wall bands)
prof = [(0.012, zb0 + 0.008), (0.026, zb0 + 0.030), (r_bowl, zb0 + 0.052), (0.0275, zb0 + bowl_h)]
for (r_a, z_a), (r_b, z_b) in zip(prof[:-1], prof[1:]):
parts += _ring_wall(r_a - wall, r_a, r_b - wall, r_b, z_a, z_b)
return parts
def container() -> list[trimesh.Trimesh]:
"""Open food-storage box 120 x 90 x 55 mm, wall 2.5 mm, floor 3 mm."""
spec = config.OBJECTS["container"]
L, W = 2 * spec.bbox_half[0], 2 * spec.bbox_half[1]
H = spec.height_m
wall, floor_t = 0.0025, 0.003
z0 = -H / 2.0
parts = [
_box((L, W, floor_t), (0, 0, z0 + floor_t / 2.0)),
_box((L, wall, H - floor_t), (0, -(W - wall) / 2.0, floor_t / 2.0)),
_box((L, wall, H - floor_t), (0, (W - wall) / 2.0, floor_t / 2.0)),
_box((wall, W - 2 * wall, H - floor_t), (-(L - wall) / 2.0, 0, floor_t / 2.0)),
_box((wall, W - 2 * wall, H - floor_t), ((L - wall) / 2.0, 0, floor_t / 2.0)),
]
return parts
def lid() -> list[trimesh.Trimesh]:
"""Container lid 126 x 96 x 8 mm: top plate + retaining lip."""
spec = config.OBJECTS["lid"]
L, W = 2 * spec.bbox_half[0], 2 * spec.bbox_half[1]
H = spec.height_m
plate_t = 0.003
lip = 0.003
parts = [
_box((L, W, plate_t), (0, 0, H / 2.0 - plate_t / 2.0)),
_box((L, lip, H - plate_t), (0, -(W - lip) / 2.0, -plate_t / 2.0)),
_box((L, lip, H - plate_t), (0, (W - lip) / 2.0, -plate_t / 2.0)),
_box((lip, W - 2 * lip, H - plate_t), (-(L - lip) / 2.0, 0, -plate_t / 2.0)),
_box((lip, W - 2 * lip, H - plate_t), ((L - lip) / 2.0, 0, -plate_t / 2.0)),
]
return parts
def serving_spoon() -> list[trimesh.Trimesh]:
"""Serving spoon 180 mm: handle bar + solid shallow scoop (convex — fine for collision)."""
spec = config.OBJECTS["serving_spoon"]
L = spec.height_m # long axis = x
handle_l = 0.105
handle = _box((handle_l, 0.014, 0.005), (-(L / 2.0) + handle_l / 2.0, 0, 0.002))
# scoop: squashed half-ellipsoid, dished side up; +2 mm z shift centers the merged bbox
scoop = trimesh.creation.icosphere(subdivisions=2, radius=1.0)
scoop.apply_scale([0.0375, 0.020, 0.008])
scoop.vertices[:, 2] = np.minimum(scoop.vertices[:, 2], 0.004)
scoop = trimesh.convex.convex_hull(scoop.vertices)
scoop.apply_translation([L / 2.0 - 0.0375, 0, 0.002])
return [handle, scoop]
BUILDERS = {
"tumbler": tumbler,
"wine_glass": wine_glass,
"container": container,
"lid": lid,
"serving_spoon": serving_spoon,
}
def build(name: str) -> list[trimesh.Trimesh]:
"""Convex parts for a procedural object (registry key or builder name)."""
if name not in BUILDERS:
raise ValueError(f"no procedural builder {name!r} (choices: {sorted(BUILDERS)})")
return BUILDERS[name]()
|