que01
24e02e2041
generate_scene.py 从 1271 → 816 行 (-455)
P0: 纯函数搬家
- osmassets/osm.py: parse_osm / Projector / parse_height
- osmassets/geom.py: clip_polygon / point_in_polygon / distance_to_ring / sample_tree_row 等
- blender/tests/test_pure.py: 42 个 unittest (脱离 bpy 运行)
P1: 单一定义源
- osmassets/catalog.py: ROAD_LAYERS + MATERIALS (含 cesium 导出参数)
- 对接 osm2streets_scene_style.json 做图层一致性 warning
- 干掉 road_mats / layer_z / 材质参数三份副本
P2: 要素注册表
- osmassets/{water,grass,scrub}.py: 每个要素一个 assemble() 函数
- build() 中的 if/elif 链收缩为注册表调用
- 计数器集中到 counts 字典
P3: 材质契约化
- catalog.py 扩展 CESIUM_EXPORT 段 (tint/metallic/emission)
- 标记已发现的死条目 Office White Metal Facade (四表各一组)
校验:
- parity.js + scene_digest.py + glb-digest.js 三位一体
- control-1 vs p0/p1/p2a/p2b/p3-counts: 两区域全 PARITY OK
- 42 个纯 Python 测试全部通过
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
127 lines
4.3 KiB
Python
127 lines
4.3 KiB
Python
"""Mesh and collection construction for the Blender scene.
|
|
|
|
Requires `bpy`; only runs inside Blender.
|
|
|
|
`MeshBatch` is the workhorse: most of the scene is flat polygons and extruded
|
|
prisms, and batching them into one mesh datablock per logical group keeps the
|
|
object count (and the glTF node count) down. Callers accumulate geometry and
|
|
call `finish()` once.
|
|
"""
|
|
|
|
import math
|
|
|
|
import bpy
|
|
|
|
|
|
def new_collection(name):
|
|
collection = bpy.data.collections.new(name)
|
|
bpy.context.scene.collection.children.link(collection)
|
|
return collection
|
|
|
|
|
|
def link_object_to_collection(obj, collection):
|
|
for current in list(obj.users_collection):
|
|
current.objects.unlink(obj)
|
|
collection.objects.link(obj)
|
|
|
|
|
|
class MeshBatch:
|
|
"""Accumulates polygons/prisms into a single mesh object."""
|
|
|
|
def __init__(self, name, collection, material):
|
|
self.name = name
|
|
self.collection = collection
|
|
self.material = material
|
|
self.vertices = []
|
|
self.faces = []
|
|
|
|
def add_polygon(self, ring, z):
|
|
if len(ring) < 3:
|
|
return
|
|
if ring[0] == ring[-1]:
|
|
ring = ring[:-1]
|
|
if len(ring) < 3:
|
|
return
|
|
start = len(self.vertices)
|
|
self.vertices.extend((x, y, z) for x, y in ring)
|
|
self.faces.append(tuple(range(start, start + len(ring))))
|
|
|
|
def add_prism(self, ring, base, height):
|
|
if len(ring) < 3:
|
|
return
|
|
if ring[0] == ring[-1]:
|
|
ring = ring[:-1]
|
|
if len(ring) < 3:
|
|
return
|
|
start = len(self.vertices)
|
|
self.vertices.extend((x, y, base) for x, y in ring)
|
|
self.vertices.extend((x, y, base + height) for x, y in ring)
|
|
n = len(ring)
|
|
self.faces.append(tuple(range(start, start + n)))
|
|
self.faces.append(tuple(range(start + n, start + 2 * n)))
|
|
for i in range(n):
|
|
j = (i + 1) % n
|
|
self.faces.append((start + i, start + j, start + n + j, start + n + i))
|
|
|
|
def finish(self):
|
|
if not self.vertices:
|
|
return None
|
|
mesh = bpy.data.meshes.new(self.name + "Mesh")
|
|
mesh.from_pydata(self.vertices, [], self.faces)
|
|
mesh.materials.append(self.material)
|
|
# Foliage reads as blobby volume, so it wants smooth normals; the built
|
|
# environment wants its facets. The name prefix is the discriminator.
|
|
if self.name.startswith("Tree_") or self.name.startswith("Scrub_"):
|
|
for polygon in mesh.polygons:
|
|
polygon.use_smooth = True
|
|
mesh.update()
|
|
obj = bpy.data.objects.new(self.name, mesh)
|
|
self.collection.objects.link(obj)
|
|
return obj
|
|
|
|
|
|
def make_prism(name, ring, base, height, material, collection):
|
|
batch = MeshBatch(name, collection, material)
|
|
batch.add_prism(ring, base, height)
|
|
return batch.finish()
|
|
|
|
|
|
def add_roof(name, ring, z, material, collection):
|
|
batch = MeshBatch(name + "_Roof", collection, material)
|
|
batch.add_polygon(ring, z)
|
|
return batch.finish()
|
|
|
|
|
|
def add_wall_panel(batch, start, end, base, height, thickness=0.045, inset=0.08):
|
|
"""Add a thin inset slab along a facade edge, used for window bands."""
|
|
dx, dy = end[0] - start[0], end[1] - start[1]
|
|
length = math.hypot(dx, dy)
|
|
if length < 3.0:
|
|
return
|
|
ux, uy = dx / length, dy / length
|
|
a = (start[0] + dx * inset, start[1] + dy * inset)
|
|
b = (end[0] - dx * inset, end[1] - dy * inset)
|
|
nx, ny = -uy * thickness / 2, ux * thickness / 2
|
|
panel = [(a[0] + nx, a[1] + ny), (b[0] + nx, b[1] + ny),
|
|
(b[0] - nx, b[1] - ny), (a[0] - nx, a[1] - ny)]
|
|
batch.add_prism(panel, base, height)
|
|
|
|
|
|
def add_polyline(name, coords, projector, collection, material, width, z):
|
|
"""Bevelled curve along lon/lat coordinates; the OSM highway road fallback."""
|
|
points = [projector.xy(c) for c in coords]
|
|
if len(points) < 2:
|
|
return
|
|
curve = bpy.data.curves.new(name, "CURVE")
|
|
curve.dimensions = "3D"
|
|
curve.resolution_u = 1
|
|
curve.bevel_depth = width / 2
|
|
curve.bevel_resolution = 1
|
|
spline = curve.splines.new("POLY")
|
|
spline.points.add(len(points) - 1)
|
|
for point, (x, y) in zip(spline.points, points):
|
|
point.co = (x, y, z, 1)
|
|
obj = bpy.data.objects.new(name, curve)
|
|
collection.objects.link(obj)
|
|
obj.data.materials.append(material)
|