"""PyVista 3D インタラクティブビューアモジュール． シーンのメッシュ・LED・センサを PyVista で可視化する． 照度ベイク結果 (irradiance) があればメッシュを照度で着色する． ## 投影モード（--render 引数） luminance_map（2D 輝度マップ, np.ndarray）が指定された場合、 評価板メッシュ（id="evaluation_board"）の各頂点を orthographic センサ規約で 2D 輝度マップへ射影し、per-vertex scalar で着色する． 投影規約の詳細は visualize/projection.py の docstring を参照． 投影モードでは: - 評価板が主役：viridis カラーマップ + scalar bar 1 本（単位: Irradiance (W/m²)） - 輝度マップは E_board = π * luminance_map / ρ で照度 (W/m²) に換算する （ρ = 評価板材料の拡散反射率、Lambertian 拡散面前提） - 他メッシュは半透明ニュートラル（グレー, opacity=0.2） - 配色は percentile クリップで高ダイナミックレンジ潰れを防止 ## ハイブリッドモード（luminance_map + irradiance 同時指定時） luminance_map と irradiance dict が**両方**指定された場合： - 評価板メッシュ（id 特定は projection.find_eval_board_mesh_id）: 投影輝度を E_board = π * L / ρ で照度 (W/m²) に換算し、 壁ベイク irradiance と**共有スケール・共有カラーバー 1 本**で着色する． - 評価板以外の全メッシュ（壁・筐体等）: irradiance dict の per-face 照度で着色（viridis・半透明 bake_opacity）． 評価板 E_board を含めた全データで算出した共有 clim を適用する． - depth peeling 有効化（半透明メッシュ混在のため）． ## ベイクモード（irradiance dict のみ指定時） irradiance dict が指定された場合は各メッシュの per-face 照度で着色する． **全メッシュ共有カラーマップ（共有 clim）**: 全メッシュ全 face の値を結合して percentile クリップ（p1–p99）で [vmin, vmax] を算出し、全 add_mesh に渡す． これにより全メッシュが同一スケールで着色される（path ベイクで壁面と評価板を比較可能）． スカラバーは 1 本のみ（単位: Irradiance (W/m²)）． mode="direct"（shadow ray）でも mode="path"（多重反射込み）でも共通して使用する． ## log スケール着色（bake_scale="log"、既定） 壁面ベイクの irradiance は高ダイナミックレンジ（LED 至近: ~4400 W/m²、壁一般: 数十〜数百）を 持つため、linear + percentile クリップでは少数の超高輝度 face が clim を支配し 大多数の壁が viridis 最下色（濃紫）に圧縮される． bake_scale="log" 時の処理順序（ベイク着色経路のみ）: 1. hide_below フィルタ: irradiance <= hide_below の cell を除去（linear 値基準）． 2. log 変換: log10(max(irradiance, eps)) を全残 face に適用（eps=1e-3）． 3. log 空間で共有 clim 算出（percentile クリップ） → scalar bar タイトル「Irradiance (W/m², log10)」． 4. bake_smooth 平滑化: log 空間スカラに対して Laplacian 拡散（N 回 往復）． 5. cell → point 補間（Gouraud シェーディング用）． 6. add_mesh． bake_scale="linear" 時は従来どおり（後方互換）． ## 評価板照度換算（E_board） 評価板の輝度マップ L（W/(m²·sr)）は Lambertian 拡散面の関係式により 入射照度 E（W/m²）に換算できる: E = π * L / ρ ρ: 評価板材料の拡散反射率（scene_config の materials から取得、既定 0.85） Lambertian 拡散面では L = ρ * E / π が成立（SPEC_03「筐体（材料）」参照）． この換算により評価板テクスチャと壁ベイク照度が同一物理量（W/m²）になり、 共有スケール・単一カラーバーで直接比較できる． """ from __future__ import annotations import logging from pathlib import Path from typing import TYPE_CHECKING import numpy as np from sm_tias_lightsim.geometry.loader import load_stl from sm_tias_lightsim.geometry.transforms import scale_vertices from sm_tias_lightsim.scene.schema import ( AreaLight, DirectionalLight, PointLight, SceneConfig, ) if TYPE_CHECKING: import pyvista as pv _logger = logging.getLogger(__name__) # YAML 座標 (mm) → m 変換係数 _MM_TO_M = 0.001 # 方向ベクトルの長さがこれ以下なら縮退とみなしてスキップする _DIR_NORM_EPSILON = 1e-9 # 光源・センサを示す球の半径（m 単位） _MARKER_SPHERE_RADIUS = 0.005 # AreaLight の放射方向矢印のスケール（m 単位） _AREA_LIGHT_ARROW_SCALE = 0.02 # DirectionalLight の矢印をシーン対角線長に対して拡大する比率 _DIRECTIONAL_ARROW_SCALE_RATIO = 0.3 # センサの視線矢印をシーン対角線長に対してクランプする比率 _SENSOR_ARROW_SCALE_RATIO = 0.2 # 投影モードで評価板以外のメッシュの不透明度 _BACKGROUND_MESH_OPACITY = 0.2 # 直接ベイクモードで着色メッシュ以外の不透明度 _UNBAKED_MESH_OPACITY = 0.5 # 評価板反射率のフォールバック値（SPEC_03 基準設計値 printer_white） _FALLBACK_RHO = 0.85 # log10 変換の下限：irradiance が 0 や負の face を log10 で -3 に揃える _LOG10_EPS = 1e-3 def _build_pyvista_polydata(vertices: np.ndarray, faces: np.ndarray) -> pv.PolyData: """頂点・面配列から PyVista PolyData を構築する． PyVista の faces 形式は各行が [n_vertices, v0, v1, v2, ...] の 1D フラット配列． Args: vertices: 頂点配列 (N_v, 3)，m 単位． faces: 三角形面配列 (N_f, 3)，頂点インデックス． Returns: PyVista PolyData オブジェクト． """ import pyvista as pv n_faces = len(faces) # PyVista 形式: [3, v0, v1, v2, 3, v0, v1, v2, ...] pv_faces = np.hstack([np.full((n_faces, 1), 3, dtype=np.int64), faces]).flatten() return pv.PolyData(vertices.astype(np.float32), pv_faces) def _get_scene_bbox_center_and_diag( scene_config: SceneConfig, project_root: Path ) -> tuple[np.ndarray, float]: """シーン全メッシュのバウンディングボックス中心と対角線長を返す． DirectionalLight の矢印位置を決めるために使う． メッシュが空なら原点と 1.0 を返す． Args: scene_config: SceneConfig． project_root: STL 相対パスの基点ディレクトリ． Returns: (center (3,), diagonal_length) のタプル． """ all_vertices: list[np.ndarray] = [] for mesh_cfg in scene_config.geometry.meshes: try: raw_path = Path(mesh_cfg.path) stl_path = raw_path if raw_path.is_absolute() else project_root / mesh_cfg.path loaded = load_stl(stl_path, mesh_cfg.unit) scaled = scale_vertices(loaded, target_unit="m") all_vertices.append(scaled.vertices) except Exception as exc: _logger.warning("バウンディングボックス計算でメッシュを読み込めませんでした: %s", exc) if not all_vertices: return np.zeros(3), 1.0 combined = np.vstack(all_vertices) mins = combined.min(axis=0) maxs = combined.max(axis=0) center = (mins + maxs) / 2.0 diagonal = float(np.linalg.norm(maxs - mins)) return center, max(diagonal, 1e-6) def _apply_percentile_clip(values: np.ndarray, clip_low: float, clip_high: float) -> np.ndarray: """percentile クリップを適用して高 DR 潰れを防ぐ． Args: values: スカラ配列． clip_low: 下限 percentile（%）． clip_high: 上限 percentile（%）． Returns: クリップ済みの配列（元と同 dtype）． """ p_low = float(np.percentile(values, clip_low)) p_high = float(np.percentile(values, clip_high)) return np.clip(values, p_low, p_high) def _get_eval_board_reflectance( scene_config: SceneConfig, eval_board_id: str, ) -> float: """評価板メッシュの拡散反射率 ρ をスカラ値で返す． scene_config の materials から評価板の material を特定し、 DiffuseMaterial の reflectance を Rec.709 輝度でスカラ化して返す． 取得できない場合は 0.85 をフォールバック値とする（SPEC_03 基準設計値）． Args: scene_config: 検証済み SceneConfig． eval_board_id: 評価板メッシュの id 文字列． Returns: 拡散反射率 ρ（スカラ, 0 < ρ ≤ 1）． """ from sm_tias_lightsim.scene.schema import DiffuseMaterial try: eval_mesh_cfg = next(m for m in scene_config.geometry.meshes if m.id == eval_board_id) material = scene_config.materials.get(eval_mesh_cfg.material) if material is None or not isinstance(material, DiffuseMaterial): _logger.warning( "評価板材料が DiffuseMaterial でないため ρ=%.2f にフォールバックします" "（material=%s）", _FALLBACK_RHO, eval_mesh_cfg.material, ) return _FALLBACK_RHO ref = material.reflectance if isinstance(ref, (int, float)): rho = float(ref) else: # RGB タプル → Rec.709 輝度でスカラ化 # Rec.709: Y = 0.2126 R + 0.7152 G + 0.0722 B r, g, b = float(ref[0]), float(ref[1]), float(ref[2]) rho = 0.2126 * r + 0.7152 * g + 0.0722 * b if rho <= 0.0 or rho > 1.0: _logger.warning( "評価板の reflectance=%.4f が有効範囲外のため ρ=%.2f にフォールバックします", rho, _FALLBACK_RHO, ) return _FALLBACK_RHO _logger.info( "評価板 reflectance 取得: material='%s' raw_ref=%s ρ=%.4f", eval_mesh_cfg.material, ref, rho, ) return rho except StopIteration: _logger.warning( "評価板メッシュ '%s' が見つかりません．ρ=%.2f にフォールバックします", eval_board_id, _FALLBACK_RHO, ) return _FALLBACK_RHO except Exception as exc: _logger.warning( "評価板反射率の取得中にエラー: %s．ρ=%.2f にフォールバックします", exc, _FALLBACK_RHO, ) return _FALLBACK_RHO def _make_irradiance_texture( irradiance_map: np.ndarray, vmin: float, vmax: float, bake_scale: str, log10_eps: float, ) -> pv.Texture: """照度マップ（W/m²）を共有スケールで viridis 着色した PyVista Texture を生成する． 評価板の E_board（照度マップ, W/m²）を壁ベイクと同一の [vmin, vmax] および log/linear 変換規約で RGB uint8 画像化し pv.Texture として返す． 共有 clim（壁ベイクと評価板の結合 percentile）は呼び出し側で算出済みの vmin/vmax をそのまま受け取る（この関数は再算出しない）． 処理手順: 1. bake_scale=="log" のとき log10(max(irradiance_map, log10_eps)) を適用する． vmin/vmax も log 空間の値（呼び出し側が変換済み）であること． 2. [vmin, vmax] で [0, 1] 正規化する． 3. matplotlib viridis で RGBA → RGB uint8 (H, W, 3) 画像化する． 4. pv.Texture を生成して返す． テクスチャ画像の行列方向は irradiance_map の (row, col) と同一（PyVista が VTK の 左下原点 UV 系でサンプリングするため、UV 側で v 反転を行う）． Args: irradiance_map: 2D 照度マップ (H, W)（W/m²）． vmin: 正規化の下限（log 空間のとき log10 済み値）． vmax: 正規化の上限（log 空間のとき log10 済み値）． bake_scale: "log" または "linear"．壁ベイクと同一の変換規約を適用する． log10_eps: log 変換時のゼロ除算防止下限値（bake_scale=="log" 時のみ使用）． Returns: pv.Texture（viridis 着色・RGB uint8）． """ import matplotlib import pyvista as pv irr2d = irradiance_map.astype(np.float64) if bake_scale == "log": # 壁ベイクと同一の log10 変換 values = np.log10(np.maximum(irr2d, log10_eps)) else: values = irr2d # [vmin, vmax] → [0, 1] 正規化（vmin==vmax の場合はゼロ除算防止） if vmax <= vmin: normalized = np.zeros_like(values) else: normalized = np.clip((values - vmin) / (vmax - vmin), 0.0, 1.0) # viridis で RGBA (H, W, 4) → RGB uint8 (H, W, 3) # matplotlib 3.7+ では colormaps[] を使う（get_cmap は非推奨） viridis = matplotlib.colormaps["viridis"] rgba = viridis(normalized) # (H, W, 4) float64 rgb = (rgba[:, :, :3] * 255).astype(np.uint8) texture = pv.Texture(rgb) _logger.info( "E_board テクスチャ生成: shape=%s bake_scale=%s " "E_board 値範囲=[%.4e, %.4e] 正規化 clim=[%.4f, %.4f]", rgb.shape, bake_scale, float(irr2d.min()), float(irr2d.max()), vmin, vmax, ) return texture def _prepare_projection_scalars( scene_config: SceneConfig, project_root: Path, luminance_map: np.ndarray, clip_low: float, clip_high: float, ) -> tuple[str | None, np.ndarray | None, np.ndarray | None, np.ndarray | None]: """投影モード用に評価板 id・per-vertex 輝度スカラ・UV 座標・カメラ向き face マスクを準備する． 評価板メッシュを特定して STL をロードし、orthographic 投影で per-vertex 輝度スカラ配列と UV テクスチャ座標を計算して返す． また、各 face がカメラ（センサ）に面しているかを判定する bool マスクも返す． Args: scene_config: 検証済み SceneConfig． project_root: STL 相対パスの基点ディレクトリ． luminance_map: sm-render 出力の 2D 輝度マップ (H, W) または (H, W, C)． clip_low: percentile クリップの下限（%）． clip_high: percentile クリップの上限（%）． Returns: (eval_board_id, projected_scalars, vertex_uv, camera_face_mask) のタプル． projected_scalars は per-vertex 輝度スカラ (N_v,)（フォールバック用）． vertex_uv は per-vertex UV テクスチャ座標 (N_v, 2) float32． camera_face_mask は per-face bool マスク (N_f,)（True = カメラ向き内側面）． 失敗時は (None, None, None, None) を返す（例外は投げない）． """ from sm_tias_lightsim.visualize.projection import ( compute_face_camera_mask, compute_orthographic_uv, find_eval_board_mesh_id, project_luminance_to_vertices, ) eval_board_id = find_eval_board_mesh_id(scene_config) _logger.info("投影モード: 評価板メッシュ id = '%s'", eval_board_id) eval_mesh_cfg = next(m for m in scene_config.geometry.meshes if m.id == eval_board_id) try: raw_path = Path(eval_mesh_cfg.path) stl_path = raw_path if raw_path.is_absolute() else project_root / eval_mesh_cfg.path eval_loaded = load_stl(stl_path, eval_mesh_cfg.unit) eval_scaled = scale_vertices(eval_loaded, target_unit="m") # 輝度マップの形状を取得（UV 算出に使用） lum_shape = (luminance_map.shape[0], luminance_map.shape[1]) projected_scalars = project_luminance_to_vertices( eval_scaled.vertices, luminance_map, scene_config.sensor, clip_low=clip_low, clip_high=clip_high, ) vertex_uv = compute_orthographic_uv( eval_scaled.vertices, lum_shape, scene_config.sensor, ) camera_face_mask = compute_face_camera_mask( eval_scaled.vertices, eval_scaled.faces, scene_config.sensor, ) _logger.info( "投影スカラ: min=%.4f, max=%.4f, std=%.4f", float(projected_scalars.min()), float(projected_scalars.max()), float(projected_scalars.std()), ) _logger.info( "UV 座標: u=[%.4f, %.4f] v=[%.4f, %.4f]", float(vertex_uv[:, 0].min()), float(vertex_uv[:, 0].max()), float(vertex_uv[:, 1].min()), float(vertex_uv[:, 1].max()), ) n_camera = int(camera_face_mask.sum()) n_total = len(camera_face_mask) _logger.info( "評価板 face 判定: カメラ向き（内側）=%d / 全 face=%d（外側 face=%d は除外）", n_camera, n_total, n_total - n_camera, ) print( f" 評価板 face: カメラ向き（内側・投影着色）={n_camera} / " f"全 face={n_total}（外側={n_total - n_camera} はニュートラル）" ) print( f" UV: u=[{vertex_uv[:, 0].min():.4f}, {vertex_uv[:, 0].max():.4f}]" f" v=[{vertex_uv[:, 1].min():.4f}, {vertex_uv[:, 1].max():.4f}]" ) except Exception as exc: _logger.warning("投影計算に失敗しました: %s．シーンレイアウトのみ表示します．", exc) return None, None, None, None return eval_board_id, projected_scalars, vertex_uv, camera_face_mask def _smooth_scalar_on_polydata( polydata: pv.PolyData, scalar_name: str, n_iter: int, ) -> pv.PolyData: """メッシュ上のスカラ値を Laplacian 平滑化する（頂点座標は変えない）． cell_data → point_data 変換（隣接セル平均）を n_iter 回繰り返すことで スカラの Laplacian 平滑化に相当する効果を得る． 毎回 point_data → cell_data → point_data と往復することで拡散が進む． Args: polydata: 入力 PolyData．cell_data[scalar_name] が存在すること． scalar_name: 平滑化対象のスカラ名．cell_data に格納されている前提． n_iter: 平滑化イテレーション数．0 の場合は point_data 化のみ行う（生）． Returns: point_data[scalar_name] を持つ新しい PolyData（座標は入力と同一）． cell_data のスカラは削除される（point_data のみ残す）． """ # 入力は cell_data にスカラが格納されていると仮定する # まず cell_data → point_data に変換する（隣接セル平均） pd = polydata.cell_data_to_point_data() for _ in range(n_iter): # point_data → cell_data（隣接頂点平均）→ point_data（隣接セル平均） # この往復でスカラが隣接方向へ 1 ステップ拡散する pd = pd.point_data_to_cell_data() pd = pd.cell_data_to_point_data() return pd def show_scene( scene_config: SceneConfig, project_root: Path, irradiance: dict[str, np.ndarray] | None = None, luminance_map: np.ndarray | None = None, *, off_screen: bool = False, screenshot: Path | None = None, clip_low: float = 1.0, clip_high: float = 99.0, bake_opacity: float = 0.5, hide_below: float = 0.0, bake_smooth: int = 4, bake_scale: str = "log", cull_outward: bool = True, hide_sensor_marker: bool = False, hide_led_markers: bool = False, ) -> None: """PyVista でシーンとベイク結果を表示する． メッシュ・LED・センサ・座標軸を含む 3D インタラクティブビューアを開く． 表示モードの優先順位: 1. irradiance のみ指定（luminance_map=None）の場合（ベイクモード・既定）: **全メッシュ（評価板含む）**を per-face 照度で統一着色（viridis）． 全メッシュに bake_opacity を一律適用して内部の光分布が透けて見える． 全メッシュ共有 clim（percentile クリップ）・単一 scalar bar． 2. luminance_map と irradiance が**両方**指定された場合（ハイブリッドモード）: 評価板メッシュ: 実レンダ輝度を orthographic 投影・不透明 評価板以外の全メッシュ: irradiance per-face 照度で着色（viridis・bake_opacity 半透明） 壁ベイクと評価板 E_board の共有 clim（percentile クリップ）・単一 scalar bar depth peeling 有効化（半透明メッシュ混在のため）． 3. luminance_map のみ指定（irradiance=None）の場合（投影モード）: 評価板メッシュに 2D 輝度マップを orthographic 投影して per-vertex 着色． 他メッシュは半透明ニュートラル（opacity=0.2）． scalar bar は評価板の 1 本のみ（単位: Luminance）． bake_opacity は影響しない（投影モード専用の透明度制御がある）． 4. 両方 None の場合: シーンレイアウトのみ（--no-bake 相当）． off_screen=True のときは GUI ウィンドウを開かず，screenshot が指定されていれば保存する． screenshot=None かつ off_screen=True のときは何も出力しない（no-op）． Args: scene_config: 検証済み SceneConfig． project_root: STL 相対パスの基点ディレクトリ． irradiance: {mesh_id: irradiance_per_face (N_f,)} の辞書． None かつ luminance_map も None なら着色なし（後方互換）． luminance_map: sm-render 出力の 2D 輝度マップ (H, W) または (H, W, C)． 指定時は投影モードで評価板に投影する（irradiance より優先）． off_screen: True のとき GUI ウィンドウを開かない（screenshot 専用）． screenshot: 保存先 PNG パス．指定時は off_screen で screenshot を保存する． clip_low: percentile クリップの下限（%）．既定 1． clip_high: percentile クリップの上限（%）．既定 99． bake_opacity: ベイクモードでのメッシュ不透明度（0=透明〜1=不透明）．既定 0.5． 投影モード（luminance_map 指定時）には影響しない． hide_below: ベイク着色で irradiance がこの値以下の face を描画から除外する閾値． 既定 0.0（irradiance <= 0.0 の face を非表示＝無照度の外殻を消す）． 負値指定で実質全 face を表示（後方互換的に全面表示したい場合）． 投影モード・ベイク計算ロジックには影響しない． bake_smooth: ベイク着色メッシュのスカラ Laplacian 平滑化イテレーション数． N>0 のとき cell_data_to_point_data / point_data_to_cell_data の往復を N 回繰り返し スカラを拡散させて三角形モザイクノイズを抑制する． 0 のとき平滑化なし（cell_data → point_data 変換のみ行い Gouraud 補間は有効）． 負値は 0 にクランプする． bake_scale="log" 時は log 変換後のスカラに対して平滑化する． 投影モード・ベイク計算ロジックには影響しない（評価板投影は常に per-vertex）． bake_scale: ベイク着色の輝度正規化スケール． "log"（既定）: log10 変換後に共有 clim / percentile を算出する． 高ダイナミックレンジ潰れを防ぎ、壁面にコントラストが付く． eps=1e-3 を下限として log10(max(irradiance, eps)) を適用． scalar bar タイトルは「Irradiance (W/m², log10)」． "linear": 従来どおり（後方互換）． scalar bar タイトルは「Irradiance (W/m²)」． 評価板の実レンダ投影（luminance_map）には影響しない． cull_outward: True（既定）のとき、ベイク着色経路の各メッシュについて 「シーン中心側を向く内向き face のみ」を描画し、外向き face はカリングする． 外向き（≈0 の外殻）を除くことで暗殻の濁り/見かけ段差を解消する （PoC poc_cull.py で検証済み）． 共有 clim もカリング後の内向き lit 値で percentile を算出する（PoC と同方式）． False のとき全面描画（後方互換）． --render の評価板テクスチャ投影には影響しない（壁ベイク側にのみ適用）． scene_center は描画対象メッシュ頂点全体の平均を 1 回算出して全メッシュ共通に使う． 巻き順依存の注意: 法線は STL の巻き順から算出するため、巻き順が 揃っていない STL では内向き/外向きが反転する可能性がある （poc_cull.py 検証 STL では妥当）． hide_sensor_marker: True のとき、センサマーカー（青い球＋青い視線矢印）の add_mesh を スキップする（デモ撮影用）．メッシュ着色・scalar bar・座標軸・bounds はそのまま残す． False（既定）のとき従来どおりセンサマーカーを表示する（後方互換）． hide_led_markers: True のとき、LED マーカー（PointLight 球 / AreaLight plane＋矢印 / DirectionalLight 矢印）の add_mesh をスキップする（デモ撮影用）． False（既定）のとき従来どおり LED マーカーを表示する（後方互換）． """ import pyvista as pv # bake_opacity を [0, 1] にクランプ bake_opacity = max(0.0, min(1.0, bake_opacity)) # bake_smooth を 0 以上にクランプ bake_smooth = max(0, bake_smooth) # bake_scale を正規化（未知値は "log" にフォールバック） if bake_scale not in ("linear", "log"): _logger.warning("未知の bake_scale='%s'、'log' にフォールバックします．", bake_scale) bake_scale = "log" # screenshot 指定があれば off_screen を強制する if screenshot is not None: off_screen = True plotter = pv.Plotter(off_screen=off_screen) # ベイクモード / ハイブリッドモード時に depth peeling を有効化 # （半透明メッシュの深度ブレンド崩れ対策） # 例外が出る環境もあるため try/except でフォールバックする if irradiance is not None: try: plotter.enable_depth_peeling() _logger.info("depth peeling を有効化しました．") except Exception as exc: _logger.warning("depth peeling の有効化に失敗しました（フォールバック）: %s", exc) # モード判定 # use_projection: luminance_map を評価板に投影するか # use_bake_walls: irradiance で評価板以外の壁メッシュを着色するか use_projection = luminance_map is not None # ハイブリッドモード（luminance_map + irradiance 同時指定）では # 投影モードの評価板着色＋ベイクの壁着色を同時に行う use_bake_walls = irradiance is not None # 投影モードの場合：評価板メッシュ id・per-vertex スカラ・UV・カメラ向き face マスクを準備する projected_scalars: np.ndarray | None = None vertex_uv: np.ndarray | None = None camera_face_mask: np.ndarray | None = None eval_board_id: str | None = None proj_texture: pv.Texture | None = None # 評価板照度マップ E_board (W/m²)：輝度 L を E = π*L/ρ で変換したもの e_board_map: np.ndarray | None = None eval_board_rho: float | None = None if use_projection: eval_board_id, projected_scalars, vertex_uv, camera_face_mask = _prepare_projection_scalars( scene_config, project_root, luminance_map, clip_low, clip_high, # type: ignore[arg-type] ) if eval_board_id is None: # 投影計算失敗 → レイアウト表示のみにフォールバック use_projection = False else: # 評価板の反射率 ρ を scene_config から取得する # ρ が取得できない場合は 0.85（SPEC_03 基準設計値）にフォールバックする eval_board_rho = _get_eval_board_reflectance(scene_config, eval_board_id) _eval_material = next( m.material for m in scene_config.geometry.meshes if m.id == eval_board_id ) print(f" 評価板 reflectance: ρ={eval_board_rho:.4f} （material='{_eval_material}'）") # 輝度マップ L (W/(m²·sr)) → 照度マップ E_board (W/m²) # Lambertian 拡散面: L = ρ * E / π → E = π * L / ρ # （SPEC_03「筐体（材料）」の E ≈ pixel × π / 0.85 に準拠） if luminance_map is not None: if luminance_map.ndim == 3: lum2d = luminance_map[:, :, 0].astype(np.float64) else: lum2d = luminance_map.astype(np.float64) e_board_map = (np.pi * lum2d / eval_board_rho).astype(np.float64) _logger.info( "E_board 換算: ρ=%.4f L=[%.4e, %.4e] E_board=[%.4e, %.4e] mean=%.4e", eval_board_rho, float(lum2d.min()), float(lum2d.max()), float(e_board_map.min()), float(e_board_map.max()), float(e_board_map.mean()), ) print( f" E_board 換算 (E=πL/ρ): " f"min={e_board_map.min():.4e} max={e_board_map.max():.4e} " f"mean={e_board_map.mean():.4e} (W/m^2)" ) # ---- cull_outward プレパス: scene_center と内向き face マスクを事前計算 ---- # cull_outward=True のとき、ベイク着色の各メッシュについて内向き face マスクを計算し # inward_masks に保持する（clim 算出とメッシュ描画の両方で再利用する）． # scene_center は全描画対象メッシュ頂点の平均を 1 回だけ計算して共有する（PoC と同方式）． inward_masks: dict[str, np.ndarray] = {} # {mesh_id: bool (N_f,)} — cull_outward 用 # {mesh_id: (vertices_m, faces)} — プレパスで読み込んだ頂点・面のキャッシュ _prepass_vf: dict[str, tuple[np.ndarray, np.ndarray]] = {} if cull_outward and use_bake_walls and irradiance is not None: from sm_tias_lightsim.visualize.projection import compute_inward_face_mask # Step 1: 全ベイク対象メッシュの頂点を集めて scene_center を計算する _all_verts_for_center: list[np.ndarray] = [] for mesh_cfg in scene_config.geometry.meshes: if mesh_cfg.id not in irradiance: continue try: raw_path = Path(mesh_cfg.path) stl_path = raw_path if raw_path.is_absolute() else project_root / mesh_cfg.path loaded = load_stl(stl_path, mesh_cfg.unit) scaled = scale_vertices(loaded, target_unit="m") _prepass_vf[mesh_cfg.id] = (scaled.vertices, scaled.faces) _all_verts_for_center.append(scaled.vertices) except Exception as exc: _logger.warning( "cull_outward プレパス: メッシュ '%s' 読み込みエラー（スキップ）: %s", mesh_cfg.id, exc, ) if _all_verts_for_center: _scene_center = np.vstack(_all_verts_for_center).mean(axis=0) _logger.info( "cull_outward: scene_center (m)=[%.4f, %.4f, %.4f]", float(_scene_center[0]), float(_scene_center[1]), float(_scene_center[2]), ) print( f" cull_outward: scene_center (m)=[" f"{_scene_center[0]:.4f}, {_scene_center[1]:.4f}, {_scene_center[2]:.4f}]" ) else: _scene_center = np.zeros(3) _logger.warning("cull_outward: 全頂点収集失敗、scene_center=原点にフォールバック") # Step 2: 各メッシュの内向き face マスクを計算する for mesh_cfg in scene_config.geometry.meshes: if mesh_cfg.id not in irradiance: continue if mesh_cfg.id not in _prepass_vf: continue verts_m, faces = _prepass_vf[mesh_cfg.id] try: mask = compute_inward_face_mask(verts_m, faces, _scene_center) inward_masks[mesh_cfg.id] = mask n_inward = int(mask.sum()) n_total = len(faces) _logger.info( "cull_outward: mesh='%s' inward(描画)=%d outward(カリング)=%d / total=%d", mesh_cfg.id, n_inward, n_total - n_inward, n_total, ) print( f" cull_outward: {mesh_cfg.id}:" f" inward(描画)={n_inward} outward(カリング)={n_total - n_inward}" f" / total={n_total}" ) except Exception as exc: _logger.warning( "cull_outward: mesh='%s' のマスク計算に失敗しました" "（全面描画にフォールバック）: %s", mesh_cfg.id, exc, ) # ---- 共有 clim の算出（ベイクモード / ハイブリッドモード / 投影モード単独）---- # 算出に使うデータ: # ハイブリッドモード（use_bake_walls + use_projection）: # 壁ベイク全 face irradiance ∪ E_board 全画素 → 共有 [vmin, vmax] # ベイクモード（use_bake_walls のみ）: # 壁ベイク全 face irradiance のみ # 投影モード単独（use_projection のみ、use_bake_walls=False）: # E_board のみ → 評価板用の [vmin, vmax] # cull_outward=True のとき壁ベイクの clim 算出は内向き face のみを使う（PoC と同方式）． # bake_scale="log" 時は log 変換後（log 空間）の値で算出する． shared_vmin: float | None = None shared_vmax: float | None = None bake_scalar_bar_added = False # 共有 scalar bar を 1 本だけ追加するフラグ # clim 算出用の値リスト（壁ベイク + E_board を結合する） _clim_value_chunks: list[np.ndarray] = [] if use_bake_walls and irradiance is not None: # 壁ベイク face irradiance を追加 # cull_outward=True のとき内向き face のみを使う（カリング後の lit 値で締める） for mesh_id, irr in irradiance.items(): if len(irr) == 0: continue if cull_outward and mesh_id in inward_masks: # カリング後の内向き face のみで clim を算出する（PoC と同方式） mask = inward_masks[mesh_id] if mask.sum() > 0: _clim_value_chunks.append(irr[mask].astype(np.float64)) else: _clim_value_chunks.append(irr.astype(np.float64)) if use_projection and e_board_map is not None: # 評価板の E_board（照度マップ全画素）を追加 _clim_value_chunks.append(e_board_map.ravel().astype(np.float64)) if _clim_value_chunks: all_values_combined = np.concatenate(_clim_value_chunks) if bake_scale == "log": # log 変換後の値で clim を算出する（log 空間の percentile） all_values_for_clim = np.log10(np.maximum(all_values_combined, _LOG10_EPS)) else: all_values_for_clim = all_values_combined # ---- lit フィルタ: 無照度（floor 値）の face を clim 算出から除外 ---- # log モード: log 変換後の値が log10(_LOG10_EPS) に張り付いた face は # 実質ゼロ照度（無照度 floor）であり、percentile を歪める原因になる． # log10(_LOG10_EPS) = -3.0 より僅かに大きい値のみを lit とみなし clim 算出に使う． # linear モード: linear 値が _LOG10_EPS（=1e-3 W/m²）より大きい face のみを lit とする． # 一貫性のため log モードと同じ絶対閾値を基準とする． # いずれも _LOG10_EPS を閾値の根拠とすることでハードコードを避ける． if bake_scale == "log": _lit_threshold_log = np.log10(_LOG10_EPS) _lit_mask = all_values_for_clim > _lit_threshold_log else: _lit_mask = all_values_for_clim > _LOG10_EPS _n_lit = int(_lit_mask.sum()) _n_total = len(_lit_mask) _logger.info( "lit フィルタ: lit=%d / total=%d (%.1f%%)", _n_lit, _n_total, 100.0 * _n_lit / max(_n_total, 1), ) if _n_lit >= 2: # lit 値のみで percentile を算出（無照度 floor による clim 過大を防ぐ） _values_for_percentile = all_values_for_clim[_lit_mask] _clim_source = "lit のみ" else: # lit 要素が極端に少ない場合は全結合で算出（ゼロ除算/空配列回避） _values_for_percentile = all_values_for_clim _clim_source = "全結合（lit 不足によるフォールバック）" _logger.warning( "lit face 数が不足（%d 個）のため全結合で clim を算出します（フォールバック）．", _n_lit, ) shared_vmin = float(np.percentile(_values_for_percentile, clip_low)) shared_vmax = float(np.percentile(_values_for_percentile, clip_high)) _logger.info( "共有 clim (%s 空間, %s): vmin=%.4e vmax=%.4e (percentile %.1f–%.1f)", bake_scale, _clim_source, shared_vmin, shared_vmax, clip_low, clip_high, ) print( f" 共有 clim ({bake_scale} 空間, {_clim_source}): " f"vmin={shared_vmin:.4e} vmax={shared_vmax:.4e} " f"(p{clip_low:.0f}-p{clip_high:.0f})" ) # 投影モードのテクスチャは共有 clim が確定した後に生成する if use_projection and e_board_map is not None and shared_vmin is not None: try: proj_texture = _make_irradiance_texture( e_board_map, shared_vmin, shared_vmax, # type: ignore[arg-type] bake_scale, _LOG10_EPS, ) except Exception as exc: _logger.warning( "E_board テクスチャ生成に失敗しました（フォールバック: per-vertex）: %s", exc ) proj_texture = None # ---- メッシュ追加 ---- # scalar bar タイトルを bake_scale に応じて決定（投影・ベイク共通） if bake_scale == "log": _scalar_bar_title = "Irradiance (W/m^2, log10)" else: _scalar_bar_title = "Irradiance (W/m^2)" for mesh_cfg in scene_config.geometry.meshes: # プレパスでキャッシュ済みの場合はそれを再利用し、STL の二度読みを回避する if mesh_cfg.id in _prepass_vf: _cached_verts, _cached_faces = _prepass_vf[mesh_cfg.id] else: try: raw_path = Path(mesh_cfg.path) stl_path = raw_path if raw_path.is_absolute() else project_root / mesh_cfg.path loaded = load_stl(stl_path, mesh_cfg.unit) scaled = scale_vertices(loaded, target_unit="m") _cached_verts, _cached_faces = scaled.vertices, scaled.faces except Exception as exc: _logger.warning("メッシュ '%s' を読み込めませんでした: %s", mesh_cfg.id, exc) continue polydata = _build_pyvista_polydata(_cached_verts, _cached_faces) if use_projection and mesh_cfg.id == eval_board_id and projected_scalars is not None: # ハイブリッドモード（--render 指定時のみ）: 評価板をカメラ向き内側 face のみ投影着色 # render 未指定（全面統一ベイク）時はここには来ない（use_projection=False） # カメラ向き face（内側面）と非カメラ向き face（外側面）に分割して別々に描画する if camera_face_mask is not None and len(camera_face_mask) == polydata.n_cells: # cell インデックスリストで分割する all_cell_ids = np.arange(polydata.n_cells, dtype=np.int64) inner_ids = all_cell_ids[camera_face_mask] outer_ids = all_cell_ids[~camera_face_mask] # ---- 内側 face（カメラ向き）: UV テクスチャで E_board 照度マップを貼る ---- if len(inner_ids) > 0: inner_poly = polydata.extract_cells(inner_ids) if proj_texture is not None and vertex_uv is not None: # ---- テクスチャ方式（主経路）---- # extract_cells 後の頂点インデックスを vtkOriginalPointIds で取得し、 # 元メッシュ全体の vertex_uv から対応 UV を抽出する orig_ids = inner_poly.point_data["vtkOriginalPointIds"] inner_uv = vertex_uv[orig_ids] # (N_inner_v, 2) inner_poly.point_data["TextureCoordinates"] = inner_uv inner_poly.active_texture_coordinates = inner_uv plotter.add_mesh( inner_poly, texture=proj_texture, show_scalar_bar=False, label=mesh_cfg.id, opacity=1.0, ) # カラーバーを別途追加（テクスチャは自動 colorbar を作らない） # 壁ベイクと共有の単一カラーバー（E_board + 壁 irradiance 同一スケール） # ハイブリッドモードでは壁ベイクが先に追加する場合があるため未追加のみ both_clim = shared_vmin is not None and shared_vmax is not None if not bake_scalar_bar_added and both_clim: # ダミースカラ付き不可視アクターで viridis カラーバーを 1 本追加 _dummy = inner_poly.copy() _dummy.point_data["_irr_bar"] = np.linspace( shared_vmin, shared_vmax, _dummy.n_points, dtype=np.float32 ) plotter.add_mesh( _dummy, scalars="_irr_bar", cmap="viridis", clim=[shared_vmin, shared_vmax], show_scalar_bar=True, scalar_bar_args={"title": _scalar_bar_title}, opacity=0.0, ) bake_scalar_bar_added = True else: # ---- per-vertex スカラ方式（テクスチャ生成失敗時フォールバック）---- # E_board を per-vertex にサンプリングして着色する _logger.warning( "テクスチャが無効のため per-vertex E_board スカラに" "フォールバックします．" ) orig_ids = inner_poly.point_data["vtkOriginalPointIds"] # E_board_map から projected_scalars と同じ bilinear サンプリングで # per-vertex 値を取得する（近似: projected_scalars に π/ρ をスケール） if e_board_map is not None and eval_board_rho is not None: _e_board_scalars = projected_scalars * (np.pi / eval_board_rho) else: _e_board_scalars = projected_scalars inner_poly.point_data["irradiance"] = _e_board_scalars[orig_ids] show_bar = not bake_scalar_bar_added _kwargs_fb: dict = { "scalars": "irradiance", "cmap": "viridis", "show_scalar_bar": show_bar, "scalar_bar_args": {"title": _scalar_bar_title}, "label": mesh_cfg.id, "opacity": 1.0, } if shared_vmin is not None and shared_vmax is not None: _kwargs_fb["clim"] = [shared_vmin, shared_vmax] plotter.add_mesh(inner_poly, **_kwargs_fb) if show_bar: bake_scalar_bar_added = True # ---- 外側 face（非カメラ向き）: ニュートラルグレーで描画 ---- if len(outer_ids) > 0: outer_poly = polydata.extract_cells(outer_ids) plotter.add_mesh( outer_poly, color="lightgray", opacity=_BACKGROUND_MESH_OPACITY, label=f"{mesh_cfg.id}:outer", ) else: # マスクが取得できなかった場合: 全面を per-vertex E_board スカラで描画 _logger.warning( "カメラ向き face マスクが無効です（全面を投影着色）． face_mask=%s, n_cells=%d", camera_face_mask is None, polydata.n_cells, ) if e_board_map is not None and eval_board_rho is not None: _e_board_scalars_full = projected_scalars * (np.pi / eval_board_rho) else: _e_board_scalars_full = projected_scalars polydata.point_data["irradiance"] = _e_board_scalars_full show_bar = not bake_scalar_bar_added _kwargs_fb2: dict = { "scalars": "irradiance", "cmap": "viridis", "show_scalar_bar": show_bar, "scalar_bar_args": {"title": _scalar_bar_title}, "label": mesh_cfg.id, "opacity": 1.0, } if shared_vmin is not None and shared_vmax is not None: _kwargs_fb2["clim"] = [shared_vmin, shared_vmax] plotter.add_mesh(polydata, **_kwargs_fb2) if show_bar: bake_scalar_bar_added = True elif use_bake_walls and irradiance is not None and mesh_cfg.id in irradiance: # ベイクモード（全面統一）/ ハイブリッドモード: per-face 照度で着色 # 全面統一ベイク: 評価板を含む全メッシュがここに来る # ハイブリッドモード: 評価板以外のメッシュがここに来る # （評価板は上の if ブランチで投影着色済み or irradiance に含まれない） # bake_opacity を一律適用して内部の光分布が透けて見えるようにする irr = irradiance[mesh_cfg.id].astype(np.float32) # ---- cull_outward: 内向き face のみを extract_cells して描画 ---- # 外向き face（シーン外を向く ≈0 の外殻）をカリングし濁り/暗殻を除去する． # 値閾値（hide_below）でなく幾何的向きで判定するため、 # ノイズで暗い lit 面に穴が開かない（PoC poc_cull.py で確認済み）． if cull_outward and mesh_cfg.id in inward_masks: _cull_mask = inward_masks[mesh_cfg.id] _inner_ids = np.where(_cull_mask)[0].astype(np.int64) if len(_inner_ids) == 0: _logger.info( "cull_outward: メッシュ '%s' は内向き face が 0 のため非表示．", mesh_cfg.id, ) continue polydata = polydata.extract_cells(_inner_ids) irr = irr[_cull_mask] polydata.cell_data["irradiance"] = irr # ---- 処理順序（bake_scale="log" 時）---- # 1. hide_below フィルタ（linear 値基準） # 2. log 変換（log10(max(irr, eps))） # 3. bake_smooth 平滑化（log 空間スカラに対して） # 4. cell → point 補間 → add_mesh # bake_scale="linear" 時は従来どおり（平滑化 → hide_below → cell→point） if bake_scale == "log": # ---- Step 1: hide_below フィルタ（linear 値基準、cell_data 上で実行）---- n_faces_before = polydata.n_cells if hide_below >= 0.0: filtered_cd = polydata.threshold( value=hide_below, scalars="irradiance", invert=False ) else: filtered_cd = polydata n_faces_after = filtered_cd.n_cells _logger.info( "threshold フィルタ: mesh='%s' hide_below=%.4e 残 face=%d / 全 face=%d", mesh_cfg.id, hide_below, n_faces_after, n_faces_before, ) if n_faces_after == 0: _logger.info( "メッシュ '%s' は全 face が閾値以下のため非表示にします．", mesh_cfg.id ) continue # ---- Step 2: log 変換（log 空間スカラを cell_data に上書き）---- irr_after_filter = filtered_cd.cell_data["irradiance"].astype(np.float32) log_irr = np.log10(np.maximum(irr_after_filter, _LOG10_EPS)).astype(np.float32) filtered_cd.cell_data["irradiance"] = log_irr _logger.info( "log 変換: mesh='%s' log10 irradiance: min=%.4f max=%.4f std=%.4f", mesh_cfg.id, float(log_irr.min()), float(log_irr.max()), float(log_irr.std()), ) # ---- Step 3: bake_smooth 平滑化（log 空間スカラ・cell_data を入力）---- smoothed_pd = _smooth_scalar_on_polydata(filtered_cd, "irradiance", bake_smooth) _logger.info( "スカラ平滑化 (log): mesh='%s' bake_smooth=%d " "point_data irradiance: min=%.4f max=%.4f std=%.4f", mesh_cfg.id, bake_smooth, float(smoothed_pd.point_data["irradiance"].min()), float(smoothed_pd.point_data["irradiance"].max()), float(smoothed_pd.point_data["irradiance"].std()), ) filtered = smoothed_pd else: # linear モード: 従来どおり（平滑化 → hide_below → cell→point） # 平滑化はフルメッシュ（threshold 前）のスカラに対して行う # （threshold 後に行うと欠損セルの境界で近傍平均が歪むため） smoothed_pd = _smooth_scalar_on_polydata(polydata, "irradiance", bake_smooth) _logger.info( "スカラ平滑化: mesh='%s' bake_smooth=%d " "point_data irradiance: min=%.4e max=%.4e std=%.4e", mesh_cfg.id, bake_smooth, float(smoothed_pd.point_data["irradiance"].min()), float(smoothed_pd.point_data["irradiance"].max()), float(smoothed_pd.point_data["irradiance"].std()), ) n_faces_before = smoothed_pd.n_cells if hide_below >= 0.0: pd_for_threshold = smoothed_pd.point_data_to_cell_data() filtered_cd = pd_for_threshold.threshold( value=hide_below, scalars="irradiance", invert=False ) if filtered_cd.n_cells > 0: filtered = filtered_cd.cell_data_to_point_data() else: filtered = filtered_cd else: filtered = smoothed_pd n_faces_after = filtered.n_cells _logger.info( "threshold フィルタ: mesh='%s' hide_below=%.4e 残 face=%d / 全 face=%d", mesh_cfg.id, hide_below, n_faces_after, n_faces_before, ) if n_faces_after == 0: _logger.info( "メッシュ '%s' は全 face が閾値以下のため非表示にします．", mesh_cfg.id ) continue # _scalar_bar_title はメッシュループ前に bake_scale に応じて定義済み show_bar = not bake_scalar_bar_added add_mesh_kwargs: dict = { "scalars": "irradiance", "cmap": "viridis", "show_scalar_bar": show_bar, "scalar_bar_args": {"title": _scalar_bar_title}, "label": mesh_cfg.id, "opacity": bake_opacity, # Gouraud（頂点補間）シェーディングで三角形境界の硬いエッジを除去する "smooth_shading": True, # カラーマップを頂点間で線形補間する（フラット単色塗りを防ぐ） "interpolate_before_map": True, } # 共有 clim がある場合は全壁メッシュで同一スケールを適用する if shared_vmin is not None and shared_vmax is not None: add_mesh_kwargs["clim"] = [shared_vmin, shared_vmax] plotter.add_mesh(filtered, **add_mesh_kwargs) if show_bar: bake_scalar_bar_added = True elif use_projection: # 投影モード（ハイブリッドでない）または # ハイブリッドモードで irradiance に含まれないメッシュ: # 評価板以外は半透明ニュートラルグレー（背景扱い） plotter.add_mesh( polydata, color="lightgray", opacity=_BACKGROUND_MESH_OPACITY, label=mesh_cfg.id, ) else: # 着色なし: グレー半透明（--no-bake または bake 未完了メッシュ） plotter.add_mesh( polydata, color="lightgray", opacity=_UNBAKED_MESH_OPACITY, label=mesh_cfg.id, ) # ---- シーン全体のバウンディングボックス（DirectionalLight 用）---- bbox_center, bbox_diag = _get_scene_bbox_center_and_diag(scene_config, project_root) # ---- LED / 光源表示 ---- if not hide_led_markers: for light in scene_config.lights: if isinstance(light, PointLight): pos_m = [c * _MM_TO_M for c in light.position] sphere = pv.Sphere(radius=_MARKER_SPHERE_RADIUS, center=pos_m) plotter.add_mesh(sphere, color="yellow", label=f"LED:{light.id}") elif isinstance(light, AreaLight): center_m = [c * _MM_TO_M for c in light.center] size_m = [light.size[0] * _MM_TO_M, light.size[1] * _MM_TO_M] dir_vec = np.array(light.direction, dtype=np.float64) dir_norm = np.linalg.norm(dir_vec) if dir_norm > _DIR_NORM_EPSILON: dir_vec = dir_vec / dir_norm plane = pv.Plane( center=center_m, direction=dir_vec.tolist(), i_size=size_m[0], j_size=size_m[1], ) plotter.add_mesh(plane, color="orange", opacity=0.7, label=f"AreaLight:{light.id}") arrow = pv.Arrow( start=center_m, direction=dir_vec.tolist(), scale=_AREA_LIGHT_ARROW_SCALE, ) plotter.add_mesh(arrow, color="orange", label=f"AreaLight:{light.id}:dir") elif isinstance(light, DirectionalLight): # バウンディングボックス中心から矢印 1 本で進行方向を示す dir_vec = np.array(light.direction, dtype=np.float64) dir_norm = np.linalg.norm(dir_vec) if dir_norm < _DIR_NORM_EPSILON: continue dir_vec = dir_vec / dir_norm arrow_scale = bbox_diag * _DIRECTIONAL_ARROW_SCALE_RATIO arrow = pv.Arrow( start=bbox_center.tolist(), direction=dir_vec.tolist(), scale=arrow_scale, ) plotter.add_mesh(arrow, color="lightyellow", label=f"DirLight:{light.id}") # ---- センサ表示 ---- sensor_pos_m = [c * _MM_TO_M for c in scene_config.sensor.position] sensor_target_m = [c * _MM_TO_M for c in scene_config.sensor.target] if not hide_sensor_marker: sensor_sphere = pv.Sphere(radius=_MARKER_SPHERE_RADIUS, center=sensor_pos_m) plotter.add_mesh(sensor_sphere, color="blue", label="sensor") sensor_pos_arr = np.array(sensor_pos_m) sensor_target_arr = np.array(sensor_target_m) view_dir = sensor_target_arr - sensor_pos_arr view_len = np.linalg.norm(view_dir) if view_len > _DIR_NORM_EPSILON: view_dir_n = view_dir / view_len sensor_arrow = pv.Arrow( start=sensor_pos_m, direction=view_dir_n.tolist(), scale=min(float(view_len), bbox_diag * _SENSOR_ARROW_SCALE_RATIO), ) plotter.add_mesh(sensor_arrow, color="blue", label="sensor:view") # ---- 座標軸と境界表示 ---- plotter.add_axes() plotter.show_bounds(grid="back", location="outer") # ---- 投影モード: 評価板正面が見えるカメラ視点を設定 ---- if use_projection: # センサ位置から評価板を見る視点に設定 # センサは -Z 側から +Z 方向を向いているので、 # ビューワは少し引いて斜め上から俯瞰する位置に設定する sensor_pos = np.array(sensor_pos_m) sensor_tgt = np.array(sensor_target_m) # センサ位置からさらに -Z 方向（センサの裏側）に引いた位置 cam_offset = sensor_pos - sensor_tgt cam_dist = np.linalg.norm(cam_offset) if cam_dist < 1e-9: cam_dist = 0.1 # カメラを評価板正面かつ斜め上から cam_pos = sensor_pos + cam_offset / cam_dist * 0.25 cam_pos[1] += 0.05 # 少し上から plotter.camera.position = cam_pos.tolist() plotter.camera.focal_point = sensor_tgt.tolist() plotter.camera.up = (0.0, 1.0, 0.0) plotter.reset_camera() # ---- 表示 / 保存 ---- if screenshot is not None: plotter.show(screenshot=str(screenshot)) elif not off_screen: plotter.show() # off_screen=True かつ screenshot=None の場合は no-op