285 lines
11 KiB
Python
285 lines
11 KiB
Python
"""B04 지표면 5종 표현 빌더 (TIN/DTM/NURBS/implicit/meshfree).
|
|
|
|
TerrainContext에서 파생 격자·샘플을 받아 각 표현의 모델(npz)과 프리뷰
|
|
(GLB/PLY)를 저장하고 메타데이터를 반환한다.
|
|
"""
|
|
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
import numpy as np
|
|
from scipy.interpolate import RBFInterpolator, RectBivariateSpline
|
|
from scipy.spatial import Delaunay
|
|
|
|
from B04_wf1_Surface.B04_wf1_Surface_Engine_ModelContext import (
|
|
ProgressCallback,
|
|
TerrainContext,
|
|
artifact_size,
|
|
atomic_npz,
|
|
clip_and_compact_mesh,
|
|
grid_faces,
|
|
grid_vertices,
|
|
with_footprint,
|
|
write_binary_ply,
|
|
write_glb,
|
|
)
|
|
|
|
|
|
def build_tin(
|
|
context: TerrainContext, output_dir: Path, stem: str, progress: ProgressCallback
|
|
) -> dict[str, Any]:
|
|
progress(5)
|
|
points = context.sample(int(context.config["tin_max_input_points"]))
|
|
unique_xy, unique_indices = np.unique(points[:, :2], axis=0, return_index=True)
|
|
points = points[unique_indices]
|
|
if len(points) < 3:
|
|
raise ValueError("TIN 생성에 필요한 포인트가 부족합니다.")
|
|
progress(25)
|
|
faces = np.asarray(Delaunay(unique_xy).simplices, dtype=np.uint32)
|
|
if len(faces):
|
|
triangle_xy = points[faces, :2]
|
|
edges = np.stack(
|
|
[
|
|
np.linalg.norm(triangle_xy[:, 0] - triangle_xy[:, 1], axis=1),
|
|
np.linalg.norm(triangle_xy[:, 1] - triangle_xy[:, 2], axis=1),
|
|
np.linalg.norm(triangle_xy[:, 2] - triangle_xy[:, 0], axis=1),
|
|
],
|
|
axis=1,
|
|
)
|
|
faces = faces[np.max(edges, axis=1) <= float(context.config["tile_size_meters"]) * 2]
|
|
valid_vertices = context.contains_xy(points[:, 0], points[:, 1])
|
|
points, faces = clip_and_compact_mesh(points, faces, valid_vertices)
|
|
if not len(faces):
|
|
raise ValueError("외곽 안쪽 기준 적용 후 TIN 면이 남지 않았습니다.")
|
|
progress(65)
|
|
model_path = output_dir / f"{stem}.npz"
|
|
preview_path = output_dir / f"{stem}_preview.glb"
|
|
atomic_npz(model_path, vertices=points, faces=faces)
|
|
write_glb(preview_path, points, faces, context.bounds)
|
|
progress(100)
|
|
return with_footprint(
|
|
context,
|
|
{
|
|
"representation": "triangular_mesh",
|
|
"model_file": model_path.name,
|
|
"preview_file": preview_path.name,
|
|
"preview_media_type": "model/gltf-binary",
|
|
"vertex_count": int(len(points)),
|
|
"face_count": int(len(faces)),
|
|
"artifact_bytes": artifact_size(model_path, preview_path),
|
|
},
|
|
)
|
|
|
|
|
|
def build_dtm(
|
|
context: TerrainContext, output_dir: Path, stem: str, progress: ProgressCallback
|
|
) -> dict[str, Any]:
|
|
progress(10)
|
|
resolution = float(context.config["dtm_grid_resolution_meters"])
|
|
x_coords, y_coords, z_grid = context.grid(resolution)
|
|
progress(55)
|
|
preview_x, preview_y, preview_z = context.preview_grid(resolution)
|
|
vertices = grid_vertices(preview_x, preview_y, preview_z)
|
|
faces = grid_faces(len(preview_y), len(preview_x))
|
|
valid_grid = context.contains_xy(*np.meshgrid(x_coords, y_coords)).reshape(
|
|
len(y_coords), len(x_coords)
|
|
)
|
|
preview_valid = context.contains_xy(vertices[:, 0], vertices[:, 1])
|
|
vertices, faces = clip_and_compact_mesh(vertices, faces, preview_valid)
|
|
model_path = output_dir / f"{stem}.npz"
|
|
preview_path = output_dir / f"{stem}_preview.glb"
|
|
atomic_npz(
|
|
model_path,
|
|
x=x_coords,
|
|
y=y_coords,
|
|
z=z_grid,
|
|
valid_mask=valid_grid,
|
|
resolution=np.array([resolution], np.float32),
|
|
)
|
|
progress(75)
|
|
write_glb(preview_path, vertices, faces, context.bounds)
|
|
progress(100)
|
|
return with_footprint(
|
|
context,
|
|
{
|
|
"representation": "regular_grid",
|
|
"model_file": model_path.name,
|
|
"preview_file": preview_path.name,
|
|
"preview_media_type": "model/gltf-binary",
|
|
"grid_rows": int(len(y_coords)),
|
|
"grid_columns": int(len(x_coords)),
|
|
"grid_resolution_meters": resolution,
|
|
"vertex_count": int(len(vertices)),
|
|
"face_count": int(len(faces)),
|
|
"artifact_bytes": artifact_size(model_path, preview_path),
|
|
},
|
|
)
|
|
|
|
|
|
def build_nurbs(
|
|
context: TerrainContext, output_dir: Path, stem: str, progress: ProgressCallback
|
|
) -> dict[str, Any]:
|
|
degree = max(1, min(5, int(context.config["nurbs_degree"])))
|
|
patch_size = float(context.config["nurbs_patch_size_meters"])
|
|
controls = max(degree + 1, int(context.config["nurbs_control_points_per_axis"]))
|
|
control_resolution = max(patch_size / max(controls - 1, 1), 0.25)
|
|
x_control, y_control, z_control = context.grid(control_resolution)
|
|
progress(30)
|
|
spline = RectBivariateSpline(
|
|
y_control,
|
|
x_control,
|
|
z_control,
|
|
kx=min(degree, len(y_control) - 1),
|
|
ky=min(degree, len(x_control) - 1),
|
|
s=float(len(x_control) * len(y_control)) * 0.01,
|
|
)
|
|
x_preview, y_preview, _ = context.preview_grid(
|
|
float(context.config["dtm_grid_resolution_meters"])
|
|
)
|
|
z_preview = np.asarray(spline(y_preview, x_preview), dtype=np.float32)
|
|
progress(65)
|
|
vertices = grid_vertices(x_preview, y_preview, z_preview)
|
|
faces = grid_faces(len(y_preview), len(x_preview))
|
|
valid_preview = context.contains_xy(vertices[:, 0], vertices[:, 1])
|
|
vertices, faces = clip_and_compact_mesh(vertices, faces, valid_preview)
|
|
model_path = output_dir / f"{stem}.npz"
|
|
preview_path = output_dir / f"{stem}_preview.glb"
|
|
atomic_npz(
|
|
model_path,
|
|
control_x=x_control,
|
|
control_y=y_control,
|
|
control_z=z_control,
|
|
degree=np.array([degree], np.int16),
|
|
patch_size_meters=np.array([patch_size], np.float32),
|
|
)
|
|
write_glb(preview_path, vertices, faces, context.bounds)
|
|
progress(100)
|
|
return with_footprint(
|
|
context,
|
|
{
|
|
"representation": "bspline_surface",
|
|
"model_file": model_path.name,
|
|
"preview_file": preview_path.name,
|
|
"preview_media_type": "model/gltf-binary",
|
|
"degree": degree,
|
|
"control_rows": int(len(y_control)),
|
|
"control_columns": int(len(x_control)),
|
|
"vertex_count": int(len(vertices)),
|
|
"face_count": int(len(faces)),
|
|
"artifact_bytes": artifact_size(model_path, preview_path),
|
|
},
|
|
)
|
|
|
|
|
|
def build_implicit(
|
|
context: TerrainContext, output_dir: Path, stem: str, progress: ProgressCallback
|
|
) -> dict[str, Any]:
|
|
maximum = max(100, int(context.config["implicit_max_points_per_tile"]))
|
|
points = context.sample(maximum)
|
|
unique_xy, unique_indices = np.unique(points[:, :2], axis=0, return_index=True)
|
|
points = points[unique_indices]
|
|
if len(points) < 4:
|
|
raise ValueError("Implicit 생성에 필요한 포인트가 부족합니다.")
|
|
progress(20)
|
|
interpolator = RBFInterpolator(
|
|
unique_xy.astype(np.float64),
|
|
points[:, 2].astype(np.float64),
|
|
neighbors=min(64, len(points)),
|
|
smoothing=float(context.config["implicit_smoothing"]),
|
|
kernel="thin_plate_spline",
|
|
)
|
|
x_preview, y_preview, _ = context.preview_grid(
|
|
float(context.config["dtm_grid_resolution_meters"])
|
|
)
|
|
xx, yy = np.meshgrid(x_preview, y_preview)
|
|
query = np.column_stack([xx.ravel(), yy.ravel()])
|
|
z_values = np.empty(len(query), dtype=np.float32)
|
|
for start in range(0, len(query), 50_000):
|
|
end = min(start + 50_000, len(query))
|
|
z_values[start:end] = interpolator(query[start:end]).astype(np.float32)
|
|
progress(25 + int(45 * end / len(query)))
|
|
z_grid = z_values.reshape(len(y_preview), len(x_preview))
|
|
vertices = grid_vertices(x_preview, y_preview, z_grid)
|
|
faces = grid_faces(len(y_preview), len(x_preview))
|
|
valid_preview = context.contains_xy(vertices[:, 0], vertices[:, 1])
|
|
vertices, faces = clip_and_compact_mesh(vertices, faces, valid_preview)
|
|
model_path = output_dir / f"{stem}.npz"
|
|
preview_path = output_dir / f"{stem}_preview.glb"
|
|
atomic_npz(
|
|
model_path,
|
|
centers_xy=unique_xy.astype(np.float32),
|
|
center_z=points[:, 2].astype(np.float32),
|
|
smoothing=np.array([float(context.config["implicit_smoothing"])], np.float32),
|
|
)
|
|
write_glb(preview_path, vertices, faces, context.bounds)
|
|
progress(100)
|
|
return with_footprint(
|
|
context,
|
|
{
|
|
"representation": "local_rbf_height_field",
|
|
"model_file": model_path.name,
|
|
"preview_file": preview_path.name,
|
|
"preview_media_type": "model/gltf-binary",
|
|
"center_count": int(len(points)),
|
|
"vertex_count": int(len(vertices)),
|
|
"face_count": int(len(faces)),
|
|
"artifact_bytes": artifact_size(model_path, preview_path),
|
|
},
|
|
)
|
|
|
|
|
|
def build_meshfree(
|
|
context: TerrainContext, output_dir: Path, stem: str, progress: ProgressCallback
|
|
) -> dict[str, Any]:
|
|
points = context.sample(int(context.config["meshfree_max_model_points"]))
|
|
points = points[context.contains_xy(points[:, 0], points[:, 1])]
|
|
if not len(points):
|
|
raise ValueError("외곽 안쪽 기준 적용 후 Meshfree 포인트가 남지 않았습니다.")
|
|
resolution = float(context.config["dtm_grid_resolution_meters"])
|
|
x_grid, y_grid, z_grid = context.grid(resolution)
|
|
dz_dy, dz_dx = np.gradient(z_grid, resolution, resolution)
|
|
gx = np.clip(np.searchsorted(x_grid, points[:, 0]), 0, len(x_grid) - 1)
|
|
gy = np.clip(np.searchsorted(y_grid, points[:, 1]), 0, len(y_grid) - 1)
|
|
normals = np.column_stack([-dz_dx[gy, gx], -dz_dy[gy, gx], np.ones(len(points), np.float32)])
|
|
normals /= np.maximum(np.linalg.norm(normals, axis=1, keepdims=True), 1e-9)
|
|
progress(55)
|
|
preview_max = int(context.config["max_preview_vertices"])
|
|
if len(points) > preview_max:
|
|
selection = np.linspace(0, len(points) - 1, preview_max, dtype=np.int64)
|
|
preview_points, preview_normals = points[selection], normals[selection]
|
|
else:
|
|
preview_points, preview_normals = points, normals
|
|
model_path = output_dir / f"{stem}.npz"
|
|
preview_path = output_dir / f"{stem}_preview.ply"
|
|
radius = float(context.config["meshfree_point_radius_meters"])
|
|
atomic_npz(
|
|
model_path,
|
|
points=points,
|
|
normals=normals.astype(np.float32),
|
|
radius=np.array([radius], np.float32),
|
|
)
|
|
write_binary_ply(preview_path, preview_points, preview_normals, context.bounds)
|
|
progress(100)
|
|
return with_footprint(
|
|
context,
|
|
{
|
|
"representation": "meshfree_surfels",
|
|
"model_file": model_path.name,
|
|
"preview_file": preview_path.name,
|
|
"preview_media_type": "application/octet-stream",
|
|
"point_count": int(len(points)),
|
|
"preview_point_count": int(len(preview_points)),
|
|
"point_radius_meters": radius,
|
|
"artifact_bytes": artifact_size(model_path, preview_path),
|
|
},
|
|
)
|
|
|
|
|
|
BUILDERS = {
|
|
"tin": build_tin,
|
|
"dtm": build_dtm,
|
|
"nurbs": build_nurbs,
|
|
"implicit": build_implicit,
|
|
"meshfree": build_meshfree,
|
|
}
|