File size: 10,491 Bytes
bf3194a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
"""Build portable native Gaussian USD environments with static scan collisions."""
from pathlib import Path
import argparse
import gc
import hashlib
import json
import time
import runpy

import fast_simplification
import numpy as np
from plyfile import PlyData
from pxr import Gf, Sdf, Usd, UsdGeom, UsdPhysics, UsdShade, UsdVol, Vt

ROOT = Path(__file__).resolve().parents[1]
SOURCE = Path('/media/joey/ZhuoyuanSSD/sharpa11_20261107')
OUT = ROOT / 'outputs/sharpa11_20261107'


def save(path, data):
    path.write_text(json.dumps(data, ensure_ascii=False, indent=2))


def load_ply(path, mesh=False):
    # Fixed triangle lengths keep millions of Python objects out of memory.
    return PlyData.read(str(path), known_list_len={'face': {'vertex_indices': 3}} if mesh else {})


def columns(data, names):
    return np.column_stack([data[k] for k in names]).astype(np.float32)


def cameras(result, floor):
    trajectory = json.loads((result / 'trajectory.json').read_text())
    frames = [f for m in trajectory['mf_files'].values() for f in m['frames']]
    poses = np.array([f['cam2world_pose'] for f in frames])
    # Capture cameras are pitched down. Level their yaw for architectural views.
    eyes = poses[:, :3, 3].copy()
    directions = poses[:, :3, 2].copy()
    directions[:, 1] = 0
    directions /= np.maximum(np.linalg.norm(directions, axis=1, keepdims=True), 1e-8)
    eyes[:, 1] = floor - 1.40
    features = np.c_[eyes[:, [0, 2]] / 2.0, directions[:, [0, 2]] * 1.1]
    picked = [int(np.argmin(np.linalg.norm(features - np.median(features, axis=0), axis=1)))]
    distance = np.full(len(features), np.inf)
    for _ in range(47):
        distance = np.minimum(distance, np.linalg.norm(features - features[picked[-1]], axis=1))
        picked.append(int(np.argmax(distance)))
    records = []
    for n, index in enumerate(picked):
        eye = eyes[index]
        target = eye + directions[index] * 3.0
        target[1] += .22  # gentle downward pitch, keeps furniture in frame
        def world(p):
            return [float(p[0]), float(p[2]), float(floor - p[1])]
        records.append(dict(index=n, name=f'view_{n:02d}', frame_id=frames[index]['frame_id'],
                            trajectory_index=index, eye=world(eye), target=world(target),
                            focal_length_mm=21.5, horizontal_aperture_mm=36.0))
    return records, poses


def build(folder):
    start = time.monotonic()
    result = folder / 'v001/result'
    dest = OUT / folder.name.split('_')[0]
    dest.mkdir(parents=True, exist_ok=True)
    if (dest / 'build.json').exists():
        print('SKIP', folder.name, flush=True)
        return
    print('LOAD', folder.name, flush=True)
    data = load_ply(result / 'gaussian.ply')['vertex'].data
    xyz = columns(data, 'xyz')
    raw = json.loads((result / 'trajectory.json').read_text())
    poses = np.array([f['cam2world_pose'] for m in raw['mf_files'].values() for f in m['frames']])
    lo = poses[:, :3, 3].min(0) - [1.8, 0, 1.8]
    hi = poses[:, :3, 3].max(0) + [1.8, 0, 1.8]
    near = (xyz[:, 0] > lo[0]) & (xyz[:, 0] < hi[0]) & (xyz[:, 2] > lo[2]) & (xyz[:, 2] < hi[2])
    near &= (data['opacity'] > 1.0)
    eye_y = float(np.median(poses[:, 1, 3]))
    hist, edges = np.histogram(xyz[near, 1], bins=np.arange(eye_y + .65, eye_y + 2.5, .015))
    floor = float(edges[np.argmax(hist)] + .0075)
    floor_pts = xyz[near & (abs(xyz[:, 1] - floor) < .025)]
    floor = float(np.median(floor_pts[:, 1]))
    views, poses = cameras(result, floor)
    save(dest / 'candidate_cameras.json', views)
    stage = Usd.Stage.CreateNew(str(dest / 'scene.usdc'))
    world = UsdGeom.Xform.Define(stage, '/World')
    stage.SetDefaultPrim(world.GetPrim())
    UsdGeom.SetStageUpAxis(stage, 'Z')
    UsdGeom.SetStageMetersPerUnit(stage, 1.0)
    scan = UsdGeom.Xform.Define(stage, '/World/Scan')
    # Row-vector USD matrix: (x,y,z) -> (x,z,floor-y), a proper rotation.
    matrix = np.array([[1, 0, 0, 0], [0, 0, -1, 0], [0, 1, 0, 0], [0, 0, floor, 1]], float)
    scan.MakeMatrixXform().Set(Gf.Matrix4d(matrix.tolist()))
    field = UsdVol.ParticleField3DGaussianSplat.Define(stage, '/World/Scan/Gaussians')
    field.CreatePositionsAttr(Vt.Vec3fArray.FromNumpy(xyz))
    rotations = columns(data, [f'rot_{i}' for i in range(4)])
    rotations /= np.maximum(np.linalg.norm(rotations, axis=1, keepdims=True), 1e-12)
    # Vt's numpy storage is xyzw; Gaussian PLY uses wxyz.
    field.CreateOrientationsAttr(Vt.QuatfArray.FromNumpy(rotations[:, [1, 2, 3, 0]].copy()))
    scales = np.exp(columns(data, [f'scale_{i}' for i in range(3)]))
    assert np.isfinite(scales).all() and np.isfinite(xyz).all()
    field.CreateScalesAttr(Vt.Vec3fArray.FromNumpy(scales))
    alpha = 1.0 / (1.0 + np.exp(-np.clip(data['opacity'], -80, 80)))
    field.CreateOpacitiesAttr(Vt.FloatArray.FromNumpy(alpha.astype('f')))
    field.CreateRadianceSphericalHarmonicsDegreeAttr(0)
    coeff = field.CreateRadianceSphericalHarmonicsCoefficientsAttr(Vt.Vec3fArray.FromNumpy(columns(data, [f'f_dc_{i}' for i in range(3)])))
    coeff.SetMetadata('elementSize', 1)
    field.CreateProjectionModeHintAttr('perspective')
    field.CreateSortingModeHintAttr('rayHitDistance')
    field.GetPrim().CreateAttribute('colorSpace:name', Sdf.ValueTypeNames.Token).Set('srgb_rec709_display')
    UsdShade.MaterialBindingAPI.Apply(field.GetPrim())
    bind = runpy.run_path(str(ROOT / 'threedgrut/export/usd/writers/omni_material.py'))['bind_particlefield_emissive_material']
    bind(stage, field.GetPrim())
    # Include Gaussian support in the bound, even for large background splats.
    extent = np.array([(xyz - scales * 3).min(0), (xyz + scales * 3).max(0)], np.float32)
    field.CreateExtentAttr(Vt.Vec3fArray.FromNumpy(extent))
    source_count = len(data)
    del rotations, scales, alpha, xyz, data
    gc.collect()
    print('GAUSSIANS', dest.name, source_count, 'floor', floor, flush=True)
    mesh = load_ply(result / 'mesh.ply', mesh=True)
    vertices = columns(mesh['vertex'].data, 'xyz')
    face_data = mesh['face'].data['vertex_indices']
    faces = (np.stack(face_data) if face_data.dtype == object else np.asarray(face_data)).astype(np.int32)
    source_faces = len(faces)
    valid = np.isfinite(vertices).all(1)[faces].all(1)
    faces = faces[valid]
    del mesh
    if len(faces) > 900000:
        vertices, faces = fast_simplification.simplify(vertices.astype('d'), faces,
            target_count=900000, agg=5.0, preserve_border=True)
    vertices = vertices.astype('f')
    faces = faces.astype(np.int32)
    triangles = vertices[faces]
    cross = np.cross(triangles[:, 1] - triangles[:, 0], triangles[:, 2] - triangles[:, 0])
    faces = faces[np.linalg.norm(cross, axis=1) > 1e-10]
    del cross, triangles
    centers = vertices[faces].mean(1)
    cells = np.floor(centers[:, [0, 2]] / 3).astype(int)
    tiles, groups = np.unique(cells, axis=0, return_inverse=True)
    material = UsdShade.Material.Define(stage, '/World/PhysicsMaterial')
    physics = UsdPhysics.MaterialAPI.Apply(material.GetPrim())
    physics.CreateStaticFrictionAttr(.7)
    physics.CreateDynamicFrictionAttr(.5)
    physics.CreateRestitutionAttr(0.0)
    chunks = []
    for i, tile in enumerate(tiles):
        ids, remap = np.unique(faces[groups == i], return_inverse=True)
        points = vertices[ids]
        geom = UsdGeom.Mesh.Define(stage, f'/World/Scan/Collisions/Tile_{i:03d}')
        geom.CreatePointsAttr(Vt.Vec3fArray.FromNumpy(points))
        geom.CreateFaceVertexCountsAttr(Vt.IntArray.FromNumpy(np.full(len(remap) // 3, 3, np.int32)))
        geom.CreateFaceVertexIndicesAttr(Vt.IntArray.FromNumpy(remap.astype(np.int32)))
        geom.CreateSubdivisionSchemeAttr('none')
        geom.CreateDoubleSidedAttr(True)
        geom.CreateVisibilityAttr('invisible')
        geom.CreatePurposeAttr('guide')
        geom.CreateExtentAttr(Vt.Vec3fArray.FromNumpy(np.array([points.min(0), points.max(0)], 'f')))
        prim = geom.GetPrim()
        UsdPhysics.CollisionAPI.Apply(prim).CreateCollisionEnabledAttr(True)
        UsdPhysics.MeshCollisionAPI.Apply(prim).CreateApproximationAttr('none')
        prim.AddAppliedSchema('PhysxCollisionAPI')
        prim.CreateAttribute('physxCollision:contactOffset', Sdf.ValueTypeNames.Float).Set(.008)
        prim.CreateAttribute('physxCollision:restOffset', Sdf.ValueTypeNames.Float).Set(0.)
        UsdShade.MaterialBindingAPI.Apply(prim).Bind(material, materialPurpose='physics')
        chunks.append(dict(path=str(prim.GetPath()), triangles=len(remap) // 3))
    scene = UsdPhysics.Scene.Define(stage, '/World/PhysicsScene')
    scene.CreateGravityDirectionAttr(Gf.Vec3f(0, 0, -1))
    scene.CreateGravityMagnitudeAttr(9.81)
    for view in views:
        camera = UsdGeom.Camera.Define(stage, f'/World/Cameras/View_{view["index"]:02d}')
        camera.CreateFocalLengthAttr(view['focal_length_mm'])
        camera.CreateHorizontalApertureAttr(36.)
        camera.CreateVerticalApertureAttr(24.)
        camera.CreateClippingRangeAttr(Gf.Vec2f(.03, 1000.))
        camera.MakeMatrixXform().Set(Gf.Matrix4d().SetLookAt(Gf.Vec3d(*view['eye']), Gf.Vec3d(*view['target']), Gf.Vec3d(0, 0, 1)).GetInverse())
    stage.GetRootLayer().Save()
    report = dict(scene=folder.name, entry='scene.usdc', gaussian_count=source_count, sh_degree=0,
        source_mesh_triangles=source_faces, collision_triangles=len(faces), collision_tiles=chunks,
        collision_method='static concave triangle mesh, quadric simplification with preserved borders; no apartment convex hull',
        source_to_world_matrix=matrix.tolist(), floor_source_y=floor, meters_per_unit=1., up_axis='Z',
        original_gaussian_arrays_preserved=True, normalized_quaternions=True,
        source_gaussian_sha256=hashlib.file_digest((result / 'gaussian.ply').open('rb'), 'sha256').hexdigest(),
        source_mesh_sha256=hashlib.file_digest((result / 'mesh.ply').open('rb'), 'sha256').hexdigest(),
        elapsed_s=time.monotonic() - start)
    save(dest / 'build.json', report)
    print('BUILT', dest.name, 'triangles', len(faces), 'seconds', round(report['elapsed_s']), flush=True)


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('scenes', nargs='*')
    args = parser.parse_args()
    OUT.mkdir(parents=True, exist_ok=True)
    for folder in sorted(SOURCE.iterdir()):
        if not args.scenes or folder.name.split('_')[0] in args.scenes:
            build(folder)
            gc.collect()