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]()