diff --git a/.gitignore b/.gitignore index a1ec927..7839521 100644 --- a/.gitignore +++ b/.gitignore @@ -16,6 +16,9 @@ # 個人ローカルの参考画像（実機写真・データシート等） REFERENCE/ +# 目視確認用の一時スクリーンショット（リポジトリルートに上書き生成される作業ファイル） +/image.png + # MiniTias-Evaluation 側から受け取った実測リファレンスデータ（個人ローカル） reference_measurement/ diff --git a/CLAUDE.md b/CLAUDE.md index 7b09d25..e3fb948 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -7,8 +7,9 @@ 現在の進捗: フェーズ 7（実装）— Step 1〜7 完了，Step 8（基準設計キャリブレーション）進行中． Step 8 進捗: spp 校正（128→1024、ノイズ/物理差を切り分け）→ 反射率スイープ（0.75〜0.92、弱い二次レバーと判明）→ **手法訂正**: シミュ linear と実測 sRGB を直接突合していた交絡を発見．標準 sRGB OETF 順方向適用＋実測 mean アンカーで見かけ差の **約 2/3 が符号化ドメイン不一致**だったと判明．寄与順は OETF（最大）＞ ISP レンズシェーディング（残差主因候補）＞ 反射率（小）．残差 1.6〜1.9 倍は調整せず正直に保持．副次: max_depth=8 は勾配を過大評価（キャリブは depth≥12）．→ **OETF 順方向適用を sm-evaluate へ正規実装完了**（`evaluation/oetf.py` + `EvaluationConfig.oetf`、baseline 有効化・real 非適用、後方互換、参照実装と数値一致テスト済み）．[SPEC_03「キャリブレーション経過」参照](docs/04_SPEC/SPEC_03_基準設計の物理構成.md)． -補足: 内部キャリブ調整は一旦中断し、**シミュ結果の見せ方（3D ビュー）改善**に着手．評価板への実レンダ（多重反射 2D 輝度マップ）投影 + 配色/正規化/演出改善を実装完了． -次のアクション（可視化）: 壁面を **path ベイク（多重反射込み per-face、`baker.py` mode="path"）** で着色（評価板の真レンダ投影は維持）． +補足: 内部キャリブ調整は一旦中断し、**シミュ結果の見せ方（3D ビュー）改善**を実施．評価板実レンダ投影 → **path ベイク（`baker.py` mode="path"、多重反射込み per-face、scalar_rgb）** 追加 → 全メッシュ統一着色（共有 lit-clim・log・単一カラーバー）を既定化、`--render` は任意のテクスチャ投影オプション（評価板 E=π·L/ρ で同一スケール）、`--bake-cache` で 1 回計算→以後即時、`--opacity`/`--hide-below`/`--bake-smooth`/`--bake-scale` を追加．実装完了． +既知の制約（受容済み）: per-face ベイクはメッシュ境界の継ぎ目・粗メッシュのブロック感・低 samples の MC ノイズ・scalar_rgb の遅さ（高 samples 非現実的）あり．精細な評価は 2D `sm-evaluate` で行う（不変）． +次のアクション（可視化・コミット後の別タスク）: シーム/粒状感の解消には全メッシュ UV 統合＋シームレスライトマップベイク（別プロジェクト規模）．必要時に別途 `/implement`．path ベイク高速化（wavefront/GPU）も別タスク． 次のアクション（キャリブ再開時）: 残差に **LSC（ISP レンズシェーディング）順方向モデル**を当てる（物理動機づけ低自由度形、overfitting 回避・取得パラメータ数明記）． 実装済みモジュール: @@ -29,10 +30,10 @@ - `src/sm_tias_lightsim/render/output.py` — PNG / luminance.npy 出力 - `src/sm_tias_lightsim/cli/render.py` — `sm-render` CLI（YAML → PNG / luminance.npy） - `src/sm_tias_lightsim/cli/evaluate.py` — `sm-evaluate` CLI（PNG / luminance.npy → metrics.csv + figures/）．`oetf.enabled` 時は ROI 抽出後・指標算出前に sRGB OETF を順方向適用（後方互換、シミュ用設定のみ） -- `src/sm_tias_lightsim/visualize/baker.py` — 各 face 中心の直接照度ベイク（shadow ray + cosine + 距離減衰）．※直接光のみ（多重反射は path モード未実装） -- `src/sm_tias_lightsim/visualize/projection.py` — orthographic センサ投影の純関数（評価板メッシュ特定 + sm-render 2D 輝度マップを頂点へ bilinear 投影）．`sensors.py` の look_at@scale 規約と整合 -- `src/sm_tias_lightsim/visualize/viewer.py` — PyVista 3D ビューア（メッシュ着色 + LED + センサ + 座標軸）．`luminance_map` 指定で評価板に実レンダ投影着色・他メッシュ半透明化、scalar bar 一本化、percentile クリップ（既定 p1–p99）、viridis 統一 -- `src/sm_tias_lightsim/cli/visualize.py` — `sm-visualize` CLI（YAML → 3D 表示 / screenshot）．`--render `（実レンダ投影、レンダ自走なし）/ `--clip-percentile LOW HIGH` 追加 +- `src/sm_tias_lightsim/visualize/baker.py` — face 中心の照度ベイク．`mode="direct"`（shadow ray + cosine + 距離減衰、直接光のみ、後方互換）/ `mode="path"`（scalar_rgb・完全シーン・コサイン重点 hemisphere MC、多重反射込み per-face、`exclude_mesh_ids` 対応） +- `src/sm_tias_lightsim/visualize/projection.py` — orthographic センサ投影の純関数（評価板メッシュ特定 / `project_luminance_to_vertices` 頂点 bilinear 投影 / `compute_orthographic_uv` テクスチャ UV / `compute_face_camera_mask` 幾何 Z ベース巻き順非依存の評価面選択）．`sensors.py` look_at@scale 規約と整合（SPEC_03「画像↔物理の向き」検証済） +- `src/sm_tias_lightsim/visualize/viewer.py` — PyVista 3D ビューア．既定＝全メッシュ統一ベイク着色（**lit のみ共有 clim**・log/linear・単一カラーバー・`bake_opacity` 半透明・`hide_below` 非表示・`bake_smooth` 平滑化・depth peeling・viridis）；`luminance_map` 指定時＝評価板 512² テクスチャ投影（E=π·L/ρ で壁と同一 W/m² スケール、内側カメラ向き face のみ、外側ニュートラル、マスク無効時 per-vertex フォールバック） +- `src/sm_tias_lightsim/cli/visualize.py` — `sm-visualize` CLI（YAML → 3D 表示 / screenshot）．`--bake-mode {direct,path}` / `--bake-samples` / `--bake-cache `（1回計算→以後即時）/ `--opacity` / `--hide-below` / `--bake-smooth` / `--bake-scale {linear,log}` / `--clip-percentile` / `--render `（任意・テクスチャ投影）．`--render` 無し＝全面統一ベイク（既定） ※ ステップ完了時にここを更新すること． ## 必須ルール（コード実装時） diff --git "a/docs/04_SPEC/SPEC_03_\345\237\272\346\272\226\350\250\255\350\250\210\343\201\256\347\211\251\347\220\206\346\247\213\346\210\220.md" "b/docs/04_SPEC/SPEC_03_\345\237\272\346\272\226\350\250\255\350\250\210\343\201\256\347\211\251\347\220\206\346\247\213\346\210\220.md" index 7b3c7f1..dcb38c1 100644 --- "a/docs/04_SPEC/SPEC_03_\345\237\272\346\272\226\350\250\255\350\250\210\343\201\256\347\211\251\347\220\206\346\247\213\346\210\220.md" +++ "b/docs/04_SPEC/SPEC_03_\345\237\272\346\272\226\350\250\255\350\250\210\343\201\256\347\211\251\347\220\206\346\247\213\346\210\220.md" @@ -115,7 +115,7 @@ ### 制限 -- 現状 Phase A のベイク（[visualize/baker.py](../../src/sm_tias_lightsim/visualize/baker.py)）は直接照度のみで多重反射を考慮しない．多重反射込みの照度マップを得るには本ドキュメント記載の path tracer（`sm-render`）を使う． +- [visualize/baker.py](../../src/sm_tias_lightsim/visualize/baker.py) は `mode="direct"`（直接照度のみ・後方互換）に加え `mode="path"`（scalar_rgb・完全シーン・コサイン重点 hemisphere MC による**多重反射込み per-face 照度**）を実装済み．3D ビューア（`sm-visualize`）の既定は全メッシュ path ベイク統一着色で、評価板も多重反射込みで色付く．ただし per-face ベイクはメッシュ境界の継ぎ目・粗メッシュのブロック感・低 samples の MC ノイズ・scalar_rgb の遅さ（高 samples は非現実的）という方式特性があり、**評価面の精細な照度マップ評価は引き続き 2D の `sm-render`/`sm-evaluate`（path tracer）で行う**（こちらが校正済みの定量結果）．シーム解消には全メッシュ UV 統合のシームレスライトマップ基盤が必要（将来の別タスク）． - `max_depth` を超える反射は無視される．エネルギー的には `0.85^8 ≈ 27%` 減衰で小さいが、**キャリブ実測では無視できない**：同一条件で depth=8→12 にすると勾配が linear 空間で 24.65→22.08（−2.6pt）、sRGB 空間で 12.57→11.16（−1.4pt）下がった．8 回打ち切りはまさに均一化に効く後段反射を取りこぼし、勾配を系統的に過大評価する．キャリブ用途では depth≥12 を使うこと． ## 筐体（材料） diff --git a/src/sm_tias_lightsim/cli/visualize.py b/src/sm_tias_lightsim/cli/visualize.py index 0b08a24..23c86d7 100644 --- a/src/sm_tias_lightsim/cli/visualize.py +++ b/src/sm_tias_lightsim/cli/visualize.py @@ -7,11 +7,17 @@ 処理フロー: 1. YAML シーン定義を読み込み SceneConfig を得る． - 2. --render が指定された場合，luminance.npy を読み込み投影モードで表示する + 2. --render が指定された場合，luminance.npy を読み込む （sm-visualize 自身はレンダリングを実行しない）． - 3. --render 未指定かつ --no-bake 指定がない場合，bake_irradiance で直接照度を計算する． - 4. show_scene で PyVista 表示（または screenshot 保存）を行う． - 5. --output 指定があれば per-face irradiance を npz 形式で保存する． + 3. --render 未指定かつ --no-bake 指定がない場合，bake_irradiance でベイクを計算する． + 既定（render 無し）: **全メッシュ（評価板含む）**を path / direct ベイクで統一着色． + --render 指定時（任意）: 評価板はテクスチャ投影・壁は path ベイク（ハイブリッドモード）． + --render + --bake-mode path: 評価板＝投影・壁＝ベイク着色（ハイブリッド）． + --render + --bake-mode direct: 投影のみ（direct ベイクはしない、従来どおり）． + 4. --bake-cache 指定時はキャッシュ npz を読み書きする（path ベイクのみ有効）． + キャッシュが存在すれば Mitsuba 起動なしで即時読込，なければベイク後に npz 保存． + 5. show_scene で PyVista 表示（または screenshot 保存）を行う． + 6. --output 指定があれば per-face irradiance を npz 形式で保存する． """ from __future__ import annotations @@ -52,10 +58,12 @@ default=None, metavar="LUMINANCE_NPY", help=( - "sm-render が出力した luminance.npy のパス．" + "sm-render が出力した luminance.npy のパス（任意オプション）．" "指定時は評価板メッシュに 2D 輝度マップを orthographic 投影して表示する" "（sm-visualize 自身はレンダリングを実行しない）．" - "指定時は --no-bake が暗黙で有効になる（直接ベイクをスキップ）．" + "未指定（既定）: 全メッシュ（評価板含む）を bake_irradiance で統一着色する．" + "--render + --bake-mode path: ハイブリッドモード（評価板=投影・壁=ベイク）．" + "--render + --bake-mode direct: 投影のみ（direct ベイクはスキップ）．" ), ) parser.add_argument( @@ -76,6 +84,45 @@ help="照度ベイクをスキップしてシーンレイアウトのみ表示する．", ) parser.add_argument( + "--bake-mode", + choices=["direct", "path"], + default="direct", + metavar="MODE", + help=( + "照度ベイクのモード．" + "'direct'（既定）: shadow ray による直接照度のみ（後方互換）．" + "'path': コサイン重点サンプリング + Mitsuba path tracer による多重反射込み照度．" + " scalar_rgb variant を使用（LLVM / DRJIT_LIBLLVM_PATH 不要）．" + " --render 未指定時（既定）: 全メッシュ（評価板含む）をベイクで統一着色する．" + " --render + path: ハイブリッドモード（評価板=投影・壁=ベイク）．" + " --render + direct: direct ベイクはスキップし投影のみ（従来どおり）．" + ), + ) + parser.add_argument( + "--bake-samples", + type=int, + default=64, + metavar="N", + help=( + "--bake-mode path 時の face あたりサンプル数．" + "大きいほど低ノイズ・高コスト．既定: 64．" + "高速確認は 16 程度，本番は 256 以上推奨．" + "--bake-mode direct では無視される．" + ), + ) + parser.add_argument( + "--bake-cache", + type=Path, + default=None, + metavar="NPZ_PATH", + help=( + "path ベイク結果のキャッシュ npz ファイルパス（任意）．" + " 指定パスが存在すれば npz を読み込んでベイクをスキップ（Mitsuba 起動なし・即時）．" + " 存在しなければ path ベイクを実行し結果を npz に保存して次回以降キャッシュを利用．" + " --bake-mode path のときのみ有効（direct では無視）．" + ), + ) + parser.add_argument( "--screenshot", type=Path, default=None, @@ -96,6 +143,56 @@ default=False, help="ウィンドウを開かない（screenshot 専用モード）．", ) + parser.add_argument( + "--opacity", + type=float, + default=0.5, + metavar="O", + help=( + "ベイク着色モードのメッシュ不透明度（0=透明〜1=不透明、既定 0.5）．" + " 1.0 指定で完全不透明になる．" + " --render 投影モードには影響しない．" + ), + ) + parser.add_argument( + "--hide-below", + type=float, + default=0.0, + metavar="VALUE", + help=( + "ベイク着色で irradiance がこの値以下の面を非表示にする" + "（既定 0.0＝光が当たっていない面を描かない）．" + " 負値指定で全面表示（ベイク着色の全 face を描画）．" + " 投影モード・ベイク計算ロジックには影響しない．" + ), + ) + parser.add_argument( + "--bake-smooth", + type=int, + default=4, + metavar="N", + help=( + "ベイク着色メッシュのスカラ Laplacian 平滑化イテレーション数（既定 4）．" + " N>0 のとき cell↔point_data 変換を N 回往復してノイズを拡散・抑制する" + "（per-face モンテカルロノイズによる三角形モザイクを軽減）．" + " N=0 で平滑化なし（cell_data → point_data 変換のみ行い Gouraud 補間は有効）．" + " 負値は 0 にクランプ．" + " 投影モード・ベイク計算ロジックには影響しない．" + ), + ) + parser.add_argument( + "--bake-scale", + choices=["linear", "log"], + default="log", + metavar="SCALE", + help=( + "ベイク着色の輝度正規化．" + "'log'（既定）: log10 変換後に共有 clim / percentile を算出する．" + " 高ダイナミックレンジ潰れを防ぎ壁面にコントラストが付く．" + "'linear': 従来どおり（後方互換）．" + " 評価板の実レンダ投影には影響しない．" + ), + ) return parser.parse_args(argv) @@ -106,7 +203,10 @@ 1. コマンドライン引数をパースする． 2. YAML シーン定義を load_scene_yaml で読み込み，SceneConfig を得る． 3. --render が指定された場合，luminance.npy を読み込む（レンダリング実行なし）． - 4. --render 未指定かつ --no-bake がなければ bake_irradiance で照度を計算する． + 4. --no-bake がなければ bake_irradiance で照度を計算する． + --render 未指定（既定）: 全メッシュ（評価板含む）を統一ベイク着色． + --render + path: ハイブリッド（評価板=投影・壁=ベイク；評価板をベイクから除外）． + --render + direct: ベイクしない（投影のみ、従来どおり）． 5. --output が指定されていれば per-face irradiance を npz で保存する． 6. show_scene で PyVista 表示（または screenshot 保存）を行う． @@ -124,9 +224,20 @@ output_dir: Path | None = args.output.resolve() if args.output else None clip_low: float = float(args.clip_percentile[0]) clip_high: float = float(args.clip_percentile[1]) - # --render 指定時は直接ベイクをスキップ（LLVM 不要） - no_bake: bool = args.no_bake or (render_path is not None) + bake_mode: str = args.bake_mode # "direct" または "path" + bake_samples: int = int(args.bake_samples) + bake_cache_path: Path | None = args.bake_cache.resolve() if args.bake_cache else None + # モード判定: + # render 無し（既定） → 全メッシュ統一ベイク（評価板も含む） + # --render + --bake-mode path → ハイブリッドモード（評価板=投影・壁=ベイク） + # --render + --bake-mode direct → ベイクしない（投影のみ、従来どおり） + is_hybrid = (render_path is not None) and (bake_mode == "path") + no_bake: bool = args.no_bake or (render_path is not None and not is_hybrid) off_screen: bool = args.off_screen + bake_opacity: float = float(args.opacity) + hide_below: float = float(args.hide_below) + bake_smooth: int = int(args.bake_smooth) + bake_scale: str = args.bake_scale # YAML 読み込み try: @@ -165,15 +276,122 @@ # 照度ベイク irradiance: dict | None = None if not no_bake: - print("照度ベイクを開始します（直接照度のみ）...") - try: - from sm_tias_lightsim.visualize.baker import bake_irradiance + import numpy as np - irradiance = bake_irradiance(config, project_root) - print("照度ベイク完了．") - except Exception as exc: # noqa: BLE001 - print(f"エラー: 照度ベイクに失敗しました — {exc}", file=sys.stderr) - return 1 + if bake_mode == "direct": + if is_hybrid: + mode_label = "直接照度（shadow ray）- ハイブリッド（評価板除外）" + else: + mode_label = "直接照度（shadow ray）- 全メッシュ統一" + else: + if is_hybrid: + mode_label = f"path ベイク（ハイブリッドモード・壁のみ, samples={bake_samples}）" + else: + mode_label = f"path ベイク（多重反射込み・全メッシュ統一, samples={bake_samples}）" + print(f"照度ベイクを開始します（{mode_label}）...") + if bake_mode == "path": + print(" path モードは計算が重いため時間がかかります．") + if is_hybrid: + print( + " ハイブリッドモード（--render 指定）: " + "評価板メッシュはベイクから除外します（投影で着色）．" + ) + else: + print( + " 全メッシュ統一ベイク（--render 未指定）: " + "評価板を含むすべてのメッシュをベイクします．" + ) + + # ハイブリッドモード時のみ評価板メッシュをベイクから除外する + # render 未指定（全面統一ベイク）時は評価板を除外しない + exclude_ids: set[str] = set() + if is_hybrid: + from sm_tias_lightsim.visualize.projection import find_eval_board_mesh_id + + eval_board_id_for_bake = find_eval_board_mesh_id(config) + exclude_ids = {eval_board_id_for_bake} + print( + f" 評価板メッシュ '{eval_board_id_for_bake}' を" + "ベイクから除外します（投影着色のため）．" + ) + + # キャッシュ対応（path モードのみ） + cache_loaded = False + if bake_mode == "path" and bake_cache_path is not None: + if bake_cache_path.exists(): + print(f"キャッシュを読み込みます（ベイク再計算なし）: {bake_cache_path}") + try: + npz = np.load(str(bake_cache_path)) + irradiance = {k: npz[k] for k in npz.files} + # 形状・型の簡易チェック + for k, v in irradiance.items(): + if v.ndim != 1: + msg = f"キャッシュ '{k}' の配列形状が不正です: ndim={v.ndim}" + raise ValueError(msg) + cache_loaded = True + print(f"キャッシュ読み込み完了．メッシュ数={len(irradiance)}") + for mesh_id, irr in irradiance.items(): + print( + f" {mesh_id}: shape={irr.shape} min={irr.min():.4e} " + f"max={irr.max():.4e}" + ) + except Exception as exc: # noqa: BLE001 + print( + "警告: キャッシュの読み込みに失敗しました" + f"（再計算にフォールバック）— {exc}", + file=sys.stderr, + ) + irradiance = None + cache_loaded = False + + if not cache_loaded: + try: + from sm_tias_lightsim.visualize.baker import bake_irradiance + + if bake_mode == "path": + irradiance = bake_irradiance( + config, + project_root, + mode="path", + samples=bake_samples, + exclude_mesh_ids=exclude_ids, + ) + else: + irradiance = bake_irradiance( + config, + project_root, + mode="direct", + exclude_mesh_ids=exclude_ids, + ) + + # path ベイク後にキャッシュを保存する + if bake_mode == "path" and bake_cache_path is not None and irradiance: + try: + bake_cache_path.parent.mkdir(parents=True, exist_ok=True) + np.savez(str(bake_cache_path), **irradiance) + print(f"ベイクキャッシュを保存しました: {bake_cache_path}") + except Exception as exc: # noqa: BLE001 + print( + f"警告: キャッシュの保存に失敗しました — {exc}", + file=sys.stderr, + ) + except Exception as exc: # noqa: BLE001 + print(f"エラー: 照度ベイクに失敗しました — {exc}", file=sys.stderr) + return 1 + + if irradiance: + all_vals = np.concatenate([v for v in irradiance.values() if len(v) > 0]) + print( + f"照度ベイク完了．全メッシュ: min={all_vals.min():.4e} " + f"max={all_vals.max():.4e} std={all_vals.std():.4e}" + ) + for mesh_id, irr in irradiance.items(): + print( + f" {mesh_id}: min={irr.min():.4e} max={irr.max():.4e} " + f"std={irr.std():.4e} nonzero={int((irr > 0).sum())}/{len(irr)}" + ) + else: + print("照度ベイク完了（結果なし）．") elif render_path is None: print("--no-bake: 照度ベイクをスキップします．シーンレイアウトのみ表示します．") @@ -203,6 +421,10 @@ screenshot=screenshot, clip_low=clip_low, clip_high=clip_high, + bake_opacity=bake_opacity, + hide_below=hide_below, + bake_smooth=bake_smooth, + bake_scale=bake_scale, ) except Exception as exc: # noqa: BLE001 print(f"エラー: PyVista 表示に失敗しました — {exc}", file=sys.stderr) diff --git a/src/sm_tias_lightsim/visualize/baker.py b/src/sm_tias_lightsim/visualize/baker.py index 7b2b1dc..97e26b0 100644 --- a/src/sm_tias_lightsim/visualize/baker.py +++ b/src/sm_tias_lightsim/visualize/baker.py @@ -1,13 +1,21 @@ # pyright: reportCallIssue=none # Mitsuba 3 は variant ベースの動的属性解決を行うため Pylance/Pyright が # mi.* を object 型と推論し reportCallIssue を誤検知する（GUIDE_06 の方針）． -"""各メッシュ face 中心での直接照度ベイクモジュール． +"""各メッシュ face 中心での照度ベイクモジュール． -shadow ray + コサイン項 + 距離減衰による直接照度（W/m²）を計算し， +2 つのモードを提供する： + +- mode="direct": shadow ray + コサイン項 + 距離減衰による直接照度（W/m²）． + 多重反射を無視する．高速（face ×光源数の積分）． + +- mode="path": コサイン重点サンプリング + Mitsuba path tracer による多重反射込み照度（W/m²）． + E = ∫_hemisphere L_i(ω)·cosθ dω を Monte Carlo 積分で評価する． + コサイン重点サンプリングの場合 E ≈ (π/N)·Σ L_i（PDF=cosθ/π のため cosθ キャンセル）． + 完全シーン（emitter + BSDF を含む）を使うため多重反射経路もすべて積分される． + scalar_rgb variant を使用（LLVM 不要）．per-ray スカラ評価のため遅いが正確に完走する． + 計算コストは face 数 × samples 倍（直接より大幅に重い）． + {mesh_id: irradiance_per_face (N_f,) float32} の形式で返す． - -多重反射（インターリフレクション）は Phase A では無視する． -将来的に mode="path" を追加することで path tracing ベースの計算に切り替え可能． """ from __future__ import annotations @@ -181,65 +189,276 @@ scene_config: SceneConfig, project_root: Path, *, - mode: Literal["direct"] = "direct", + mode: Literal["direct", "path"] = "direct", + samples: int = 64, + exclude_mesh_ids: set[str] | None = None, ) -> dict[str, np.ndarray]: - """各メッシュの face 中心で照度（W/m²）を計算する（直接照度のみ）． + """各メッシュの face 中心で照度（W/m²）を計算する． - Phase A: shadow ray + コサイン項 + 距離減衰による直接照度のみを計算する． - 多重反射は無視する（Phase B で mode="path" を追加予定）． + 2 つのモードを提供する： - shadow ray の評価には Mitsuba の `scene.ray_intersect_preliminary` を利用する． - 遮蔽された face は寄与をスキップする． + - mode="direct"（既定）: shadow ray + コサイン項 + 距離減衰による直接照度のみ． + 多重反射を無視する．高速．scalar_rgb variant を使用． + + - mode="path": コサイン重点サンプリング + Mitsuba path tracer による多重反射込み照度． + 完全シーン（emitter + BSDF を含む）に対してパス積分を評価するため， + 内壁の多重反射で均一化された照度分布が得られる（MiniTIAS の設計目標と整合）． + **評価板は直接照度ベイクでは真っ暗になるが，path ベイクでは多重反射で非ゼロになる．** + scalar_rgb variant を使用（LLVM 不要・DRJIT_LIBLLVM_PATH 不要）． + 計算コストは face 数 × samples 倍（直接ベイクより大幅に重い）． + 目安: 100k face × samples=64 ≈ 数分（face 数依存）． Args: scene_config: 検証済み SceneConfig． project_root: STL 相対パスの基点ディレクトリ． - mode: 計算モード．現在は "direct" のみサポート． + mode: 計算モード．"direct"（直接照度, 後方互換）または "path"（多重反射込み）． + samples: mode="path" 時の face あたりサンプル数．大きいほど低ノイズだが重い． + 既定 64．高速確認は 16 程度，本番は 256 以上推奨．mode="direct" では無視． + exclude_mesh_ids: ベイク計算からスキップする mesh_id の集合（任意）． + ハイブリッドモードで評価板を投影で着色する場合に path ベイクから除外して + 計算量を節約するために使う．除外された mesh_id はキーとして返さない． Returns: {mesh_id: irradiance_per_face (N_f,) float32} の辞書． - irradiance の単位は W/m²（intensity の単位に依存）． + irradiance の単位は W/m²（light の radiance / intensity の単位に依存）． + exclude_mesh_ids に指定した id はキーに含まれない． Raises: - NotImplementedError: mode が "direct" 以外の場合． + ValueError: mode が不正な値の場合． FileNotFoundError: STL ファイルが見つからない場合． """ - if mode != "direct": - msg = f"mode={mode!r} は未サポートです．現在は 'direct' のみ実装しています．" - raise NotImplementedError(msg) + if mode not in ("direct", "path"): + msg = f"mode={mode!r} は不正です．'direct' または 'path' を指定してください．" + raise ValueError(msg) + + if exclude_mesh_ids is None: + exclude_mesh_ids = set() import mitsuba as mi from sm_tias_lightsim.scene.builder import build_scene - # Mitsuba variant を初期化（scalar_rgb を使う：shadow ray 評価に最適） - # runner.py と同じ variant が既に設定されている場合はそのまま続行する - desired_variant = "scalar_rgb" - try: - mi.set_variant(desired_variant) - except Exception: - _logger.warning( - "Mitsuba variant の切り替えに失敗しました．現在の variant で続行します．" + if mode == "direct": + # Mitsuba variant を初期化（scalar_rgb を使う：shadow ray 評価に最適） + # runner.py と同じ variant が既に設定されている場合はそのまま続行する + desired_variant = "scalar_rgb" + try: + mi.set_variant(desired_variant) + except Exception: + _logger.warning( + "Mitsuba variant の切り替えに失敗しました．現在の variant で続行します．" + ) + + # shadow ray 評価専用シーン（AreaLight の rectangle 形状を除外）を構築する． + # AreaLight を含む通常シーンでは，面光源自身の rectangle にヒットして + # 正面メッシュへの shadow ray が常に遮蔽されてしまう問題を回避するため， + # exclude_emitters=True で AreaLight をシーンから除外する． + scene_dict, tempdir = build_scene( + scene_config, project_root=project_root, exclude_emitters=True + ) + try: + scene = mi.load_dict(scene_dict) + return _bake_direct( + scene_config, project_root, scene, exclude_mesh_ids=exclude_mesh_ids + ) + finally: + shutil.rmtree(tempdir, ignore_errors=True) + + else: # mode == "path" + return _bake_path( + scene_config, project_root, samples=samples, exclude_mesh_ids=exclude_mesh_ids ) - # shadow ray 評価専用シーン（AreaLight の rectangle 形状を除外）を構築する． - # AreaLight を含む通常シーンでは，面光源自身の rectangle にヒットして - # 正面メッシュへの shadow ray が常に遮蔽されてしまう問題を回避するため， - # exclude_emitters=True で AreaLight をシーンから除外する． + +def _set_variant_once(desired_variant: str) -> None: + """Mitsuba variant をプロセス内で 1 度だけ設定する． + + 既に同じ variant が設定されている場合は何もしない． + 異なる variant が設定されている場合は警告を出して続行する（変更しない）． + + Args: + desired_variant: 設定したい variant 文字列． + """ + import mitsuba as mi + + current = mi.variant() + if current == desired_variant: + return + if current is None: + mi.set_variant(desired_variant) + else: + _logger.warning( + "Mitsuba variant は既に %r に設定されています．" + "要求された variant %r は無視されます．" + "variant を変更するにはプロセスを再起動してください．", + current, + desired_variant, + ) + + +def _bake_path( + scene_config: SceneConfig, + project_root: Path, + *, + samples: int, + exclude_mesh_ids: set[str] | None = None, +) -> dict[str, np.ndarray]: + """多重反射込み path ベイクの内部実装． + + コサイン重点サンプリングで hemisphere 方向を N 本生成し， + 各レイを Mitsuba path integrator で評価して入射照度を積分する． + + 積分式（コサイン重点サンプリング，PDF = cosθ/π）： + + E = ∫_H² L_i(ω) cosθ dω + ≈ (1/N) Σ L_i(ωk) cosθk / pdf(ωk) + = (π/N) Σ L_i(ωk) ← cosθ と PDF のコサインがキャンセル + + 完全シーン（emitter + BSDF を含む）を使うため内壁の多重反射も積分される． + scalar_rgb variant を使用（LLVM 不要）．per-ray スカラ評価のため遅いが正確に完走する． + + Args: + scene_config: 検証済み SceneConfig． + project_root: STL 相対パスの基点ディレクトリ． + samples: face あたりサンプル数．大きいほど低ノイズ・高コスト． + exclude_mesh_ids: ベイク計算からスキップする mesh_id の集合（任意）． + + Returns: + {mesh_id: irradiance_per_face (N_f,) float32}． + """ + if exclude_mesh_ids is None: + exclude_mesh_ids = set() + import mitsuba as mi + + from sm_tias_lightsim.scene.builder import build_scene + + # path ベイクは scalar_rgb variant を使う（LLVM 不要）． + # llvm_ad_rgb 等の LLVM variant を per-ray スカラループで使うと + # LLVM JIT の megakernel シンボル解決が破綻してクラッシュするため， + # scalar_rgb（JIT 無し）で per-ray 評価を行う（_bake_direct と同方式）． + _set_variant_once("scalar_rgb") + + # 完全シーン（emitter と BSDF を含む）を構築する． + # exclude_emitters=False にすることで AreaLight の rectangle も含まれ， + # path tracer が emitter を光源として正しくサンプリングできる． scene_dict, tempdir = build_scene( - scene_config, project_root=project_root, exclude_emitters=True + scene_config, project_root=project_root, exclude_emitters=False ) try: scene = mi.load_dict(scene_dict) - return _bake_direct(scene_config, project_root, scene) + integrator = scene.integrator() + sampler = mi.load_dict({"type": "independent"}) + # wavefront_size=1: 1 レイずつスカラで評価する（face ループ内で毎回呼ぶため） + sampler.seed(0, wavefront_size=1) # type: ignore[call-arg] + + result: dict[str, np.ndarray] = {} + n_meshes = len(scene_config.geometry.meshes) + + for mesh_idx, mesh_cfg in enumerate(scene_config.geometry.meshes): + if mesh_cfg.id in exclude_mesh_ids: + _logger.info( + "path ベイク: メッシュ %d/%d '%s' はスキップします（exclude_mesh_ids）", + mesh_idx + 1, + n_meshes, + mesh_cfg.id, + ) + continue + + 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") + + centroids, normals = _compute_face_centroids_and_normals(scaled.vertices, scaled.faces) + n_faces = len(centroids) + irradiance = np.zeros(n_faces, dtype=np.float64) + + _logger.info( + "path ベイク: メッシュ %d/%d '%s' faces=%d samples=%d", + mesh_idx + 1, + n_meshes, + mesh_cfg.id, + n_faces, + samples, + ) + + rng = np.random.default_rng(seed=mesh_idx) + + for fi in range(n_faces): + centroid = centroids[fi] + normal = normals[fi] + + # face 法線座標系を構築（コサイン重点サンプリングのローカル→ワールド変換用） + n_mi = mi.Vector3f(float(normal[0]), float(normal[1]), float(normal[2])) + frame = mi.Frame3f(n_mi) + + # origin を法線方向にオフセット（自己交差回避） + origin = centroid + _SHADOW_RAY_EPSILON * normal + + total_radiance = np.zeros(3, dtype=np.float64) + + for _ in range(samples): + # コサイン重点サンプリング: [0,1)² → ローカル hemisphere 方向 + u0, u1 = float(rng.random()), float(rng.random()) + local_dir = mi.warp.square_to_cosine_hemisphere(mi.Point2f(u0, u1)) + world_dir = frame.to_world(local_dir) + # scalar_rgb では Vector3f は通常の Mitsuba 型なので numpy 変換で取り出す + wd = np.array(world_dir).flatten() + + ray = mi.Ray3f( # type: ignore[call-arg] + mi.Point3f(float(origin[0]), float(origin[1]), float(origin[2])), + mi.Vector3f(float(wd[0]), float(wd[1]), float(wd[2])), + ) + + # path integrator で多重反射込みの入射放射輝度を評価する + # 返り値（Color3f, Bool）を numpy 変換して取り出す + radiance_rgb, valid, _aovs = integrator.sample( # type: ignore[call-arg] + scene, sampler, ray + ) + radiance_arr = np.array(radiance_rgb).flatten() # (3,) float32 + valid_arr = np.array(valid).flatten() # (1,) bool + + if bool(valid_arr[0]): + total_radiance[0] += float(radiance_arr[0]) + total_radiance[1] += float(radiance_arr[1]) + total_radiance[2] += float(radiance_arr[2]) + + # E = (π/N) Σ L_i (コサイン重点サンプリングの正規化) + # Σ は valid サンプルのみ．N はサンプル総数（valid 比率で bias なし） + if samples > 0: + radiance_mean = total_radiance / samples + irradiance_rgb = np.pi * radiance_mean + # スカラ照度として Rec.709 輝度に変換 + irradiance[fi] = ( + 0.2126 * irradiance_rgb[0] + + 0.7152 * irradiance_rgb[1] + + 0.0722 * irradiance_rgb[2] + ) + + result[mesh_cfg.id] = irradiance.astype(np.float32) + _logger.info( + " '%s': min=%.4e max=%.4e std=%.4e (valid_faces=%d/%d)", + mesh_cfg.id, + float(irradiance.min()), + float(irradiance.max()), + float(irradiance.std()), + int((irradiance > 0).sum()), + n_faces, + ) + finally: shutil.rmtree(tempdir, ignore_errors=True) + return result + def _bake_direct( scene_config: SceneConfig, project_root: Path, scene: object, + *, + exclude_mesh_ids: set[str] | None = None, ) -> dict[str, np.ndarray]: """直接照度ベイクの内部実装． @@ -249,22 +468,29 @@ scene_config: 検証済み SceneConfig． project_root: STL 相対パスの基点ディレクトリ． scene: Mitsuba Scene オブジェクト（load_dict 済み）． + exclude_mesh_ids: ベイク計算からスキップする mesh_id の集合（任意）． Returns: {mesh_id: irradiance_per_face (N_f,) float32}． """ + if exclude_mesh_ids is None: + exclude_mesh_ids = set() + result: dict[str, np.ndarray] = {} for mesh_cfg in scene_config.geometry.meshes: + if mesh_cfg.id in exclude_mesh_ids: + _logger.info( + "direct ベイク: メッシュ '%s' はスキップします（exclude_mesh_ids）", mesh_cfg.id + ) + continue 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") - centroids, normals = _compute_face_centroids_and_normals( - scaled.vertices, scaled.faces - ) + centroids, normals = _compute_face_centroids_and_normals(scaled.vertices, scaled.faces) n_faces = len(centroids) irradiance = np.zeros(n_faces, dtype=np.float32) @@ -314,9 +540,7 @@ continue origin = centroid + _SHADOW_RAY_EPSILON * normal - if _shadow_ray_blocked( - scene, origin, incident_dir, float(_DIRECTIONAL_MAXT) - ): + if _shadow_ray_blocked(scene, origin, incident_dir, float(_DIRECTIONAL_MAXT)): continue irradiance[fi] += float(irradiance_val * cos_theta) diff --git a/src/sm_tias_lightsim/visualize/projection.py b/src/sm_tias_lightsim/visualize/projection.py index d3eab07..bfaa090 100644 --- a/src/sm_tias_lightsim/visualize/projection.py +++ b/src/sm_tias_lightsim/visualize/projection.py @@ -69,6 +69,82 @@ _MM_TO_M = 0.001 +def _compute_camera_basis_and_col_row( + vertices_m: np.ndarray, + sensor: SensorConfig, +) -> tuple[np.ndarray, np.ndarray, int, int]: + """orthographic センサの look_at 基底を計算し、頂点の浮動小数点ピクセル座標を返す内部ヘルパ． + + 投影規約（本モジュール冒頭 docstring・SPEC_03「画像↔物理の向き」）に準拠し、 + `project_luminance_to_vertices` と `compute_orthographic_uv` が共有する + カメラ基底計算〜(col_f, row_f) 算出を一か所に集約する（DRY）． + + Args: + vertices_m: 頂点配列 (N_v, 3)，m 単位． + sensor: SceneConfig.sensor（position / target / up / ortho_scale を使用）． + + Returns: + (col_f, row_f, n_cols, n_rows) のタプル． + col_f: float 列座標 (N_v,)，範囲外頂点もクランプ前の生値を返す． + row_f: float 行座標 (N_v,)，同上． + n_cols: 輝度マップの列数（ortho_scale[0] の比率を表す整数代替ではなく + この関数内部では不使用；呼び出し側で形状から求める）． + n_rows: 同上． + 実際には (col_f, row_f, clip_x, clip_y) を返す（クランプ前 clip 値は + 範囲外チェックに使うため）． + + Raises: + ValueError: sensor.type が 'orthographic' でない場合，ortho_scale が None の場合， + または position=target / up ∥ forward のとき． + + Note: + n_cols / n_rows はこの関数の返り値には含まれない（輝度マップのサイズは + 呼び出し側が持つため）．代わりに clip_x, clip_y を返し、呼び出し側で + 画像サイズを掛けてピクセル座標に変換する． + """ + if sensor.type != "orthographic": + msg = f"投影は orthographic センサのみサポートします (type={sensor.type!r})" + raise ValueError(msg) + if sensor.ortho_scale is None: + msg = "sensor.ortho_scale が未設定です" + raise ValueError(msg) + + # ortho_scale mm → m + sx_m = sensor.ortho_scale[0] * _MM_TO_M + sy_m = sensor.ortho_scale[1] * _MM_TO_M + + # カメラ look_at 基底の計算（Mitsuba 規約） + pos_m = np.array(sensor.position, dtype=np.float64) * _MM_TO_M + target_m = np.array(sensor.target, dtype=np.float64) * _MM_TO_M + up = np.array(sensor.up, dtype=np.float64) + + forward = target_m - pos_m + forward_len = np.linalg.norm(forward) + if forward_len < 1e-9: + msg = "sensor position と target が一致しています" + raise ValueError(msg) + forward = forward / forward_len + + right = np.cross(up, forward) + right_len = np.linalg.norm(right) + if right_len < 1e-9: + msg = "sensor up ベクトルが forward と平行です" + raise ValueError(msg) + right = right / right_len + + cam_up = np.cross(forward, right) + + rot_cam_to_world = np.stack([right, cam_up, forward], axis=1) # (3, 3) + + v_rel = vertices_m - pos_m # (N_v, 3) + cam_coords = v_rel @ rot_cam_to_world # (N_v, 3) + + clip_x = cam_coords[:, 0] / sx_m + clip_y = cam_coords[:, 1] / sy_m + + return clip_x, clip_y + + def find_eval_board_mesh_id(scene_config: SceneConfig) -> str: """評価板メッシュの id を scene_config から決定する． @@ -107,6 +183,88 @@ return scene_config.geometry.meshes[0].id +def compute_face_camera_mask( + vertices_m: np.ndarray, + faces: np.ndarray, + sensor: SensorConfig, + *, + tol_m: float = 0.001, +) -> np.ndarray: + """各 face が評価板の「カメラ側（センサ側）平坦評価プレート面」かを判定する bool マスクを返す． + + ## 判定基準（幾何位置ベース・巻き順非依存） + + STL の巻き順は作者依存で信頼できないため、face 法線の内積による判定をやめ、 + face centroid の「カメラ向き主軸方向座標」が評価板メッシュのその端に集中しているか + で判定する． + + 具体的な手順: + 1. sensor の view_dir = normalize(target - position) を計算する． + 2. view_dir の各頂点への射影成分 proj = dot(vertex, view_dir) を求め、 + メッシュ全体での proj_min（センサ側端）と proj_max（反センサ側端）を得る． + baseline: sensor が -Z から +Z を向く → view_dir ≈ (0,0,1)、 + proj ≈ world_z → proj_min が評価板の最小 Z 端（Z≈-4.5mm）． + 3. 各 face の centroid の proj 値が「proj_min + tol_m 以下」の face を + 「カメラ側平坦評価プレート面」（内側面）として True にする． + - tol_m（既定 1mm）: 平坦面の数値誤差とわずかな厚みを吸収する余裕幅． + - 評価板の評価プレートは単一平面（SPEC_03: Z=-4.5mm）のため tol_m=1mm は十分大きく、 + かつ外側 AR マーカー等（Z≈-2.5mm 以上）を取り込まない適切な値． + 4. その他の face（外側の楕円窓・AR マーカー・+Z 構造）は False（ニュートラルグレー描画）． + + view_dir から向きを決めるため sensor.position / sensor.target のみに依存し、 + STL の巻き順・法線符号には依存しない． + + Args: + vertices_m: 頂点配列 (N_v, 3)，m 単位． + faces: 三角形面配列 (N_f, 3)，頂点インデックス（0-based）． + sensor: SceneConfig.sensor（position / target を使用）． + tol_m: センサ側端から数えた許容幅（m 単位，既定 0.001m = 1mm）． + 評価プレートが単一平面なら数値誤差を吸収するだけの小さい値で十分． + 外側構造が近すぎる場合は小さくする（0.0005m = 0.5mm 等）． + + Returns: + bool 配列 (N_f,)．True の face が評価対象（カメラ側平坦面・投影着色の対象）． + """ + pos_m = np.array(sensor.position, dtype=np.float64) * _MM_TO_M + target_m = np.array(sensor.target, dtype=np.float64) * _MM_TO_M + + # カメラ視線方向（センサが向いている方向） + view_dir = target_m - pos_m + view_len = np.linalg.norm(view_dir) + if view_len < 1e-9: + msg = "sensor position と target が一致しています" + raise ValueError(msg) + view_dir = view_dir / view_len # (3,) 単位ベクトル + + # 全頂点を view_dir へ射影（スカラ値） + # baseline: view_dir = (0,0,1) のとき proj ≈ world_z + proj_v = vertices_m @ view_dir # (N_v,) 各頂点の view_dir 方向成分 + + # メッシュ全体の射影範囲 + proj_min = float(proj_v.min()) # センサ側端（baseline では最小 Z 端） + + # face centroid の射影値を計算 + # face centroid = (v0 + v1 + v2) / 3 の view_dir 方向成分 = 各頂点 proj の平均 + proj_centroids = proj_v[faces].mean(axis=1) # (N_f,) + + # centroid の proj が「センサ側端 + tol_m 以内」= カメラ側平坦評価プレート面 + mask = proj_centroids <= proj_min + tol_m + + n_camera = int(mask.sum()) + n_total = len(faces) + _logger.debug( + "face カメラ側端判定 (幾何位置ベース): 評価面=%d / 全 face=%d " + "(proj_min=%.5f m, tol_m=%.4f m, 閾値=%.5f m)", + n_camera, + n_total, + proj_min, + tol_m, + proj_min + tol_m, + ) + + return mask + + def project_luminance_to_vertices( vertices_m: np.ndarray, luminance_map: np.ndarray, @@ -136,17 +294,6 @@ ValueError: sensor.type が 'orthographic' でない場合，または sensor.ortho_scale が None の場合． """ - if sensor.type != "orthographic": - msg = f"投影は orthographic センサのみサポートします (type={sensor.type!r})" - raise ValueError(msg) - if sensor.ortho_scale is None: - msg = "sensor.ortho_scale が未設定です" - raise ValueError(msg) - - # ortho_scale mm → m - sx_m = sensor.ortho_scale[0] * _MM_TO_M - sy_m = sensor.ortho_scale[1] * _MM_TO_M - # 2D マップの準備: チャネルがあれば最初のチャネルを使用 if luminance_map.ndim == 3: lum2d = luminance_map[:, :, 0].astype(np.float64) @@ -155,54 +302,8 @@ n_rows, n_cols = lum2d.shape - # --- 投影計算 --- - # センサの look_at 変換: position→target 方向が +Z（Z 軸上の特殊ケース） - # to_world = look_at @ scale(sx, sy, 1) を逆算する - # clip_x = world_x / sx_m, clip_y = world_y / sy_m - # (general look_at の場合はカメラ基底で射影が必要だが、 - # baseline では position=(0,0,-50)mm, target=(0,0,0), up=(0,1,0)なので - # look_at が恒等行列 × 平行移動のみ → 世界 XY = クリップ XY × スケール) - # - # より一般的な look_at 対応のため、カメラ基底を明示的に計算する: - pos_m = np.array(sensor.position, dtype=np.float64) * _MM_TO_M - target_m = np.array(sensor.target, dtype=np.float64) * _MM_TO_M - up = np.array(sensor.up, dtype=np.float64) - - # カメラ基底（Mitsuba look_at 規約） - # forward = normalize(target - pos) - # right = normalize(cross(up, forward)) ← Mitsuba は up × forward - # cam_up = cross(forward, right) - forward = target_m - pos_m - forward_len = np.linalg.norm(forward) - if forward_len < 1e-9: - msg = "sensor position と target が一致しています" - raise ValueError(msg) - forward = forward / forward_len - - right = np.cross(up, forward) - right_len = np.linalg.norm(right) - if right_len < 1e-9: - msg = "sensor up ベクトルが forward と平行です" - raise ValueError(msg) - right = right / right_len - - cam_up = np.cross(forward, right) - # cam_up の長さは right が単位ベクトルかつ forward と直交するので ≈ 1 - - # 頂点 → センサ基底座標 - # (right, cam_up, forward) の 3x3 変換行列 - # world_vec = rot_cam_to_world @ cam_vec → cam_vec = rot_cam_to_world^T @ world_vec - rot_cam_to_world = np.stack([right, cam_up, forward], axis=1) # (3, 3), 列=カメラ基底 - - # 頂点のカメラ相対位置 - v_rel = vertices_m - pos_m # (N_v, 3) - cam_coords = v_rel @ rot_cam_to_world # (N_v, 3)，各列は (right, cam_up, forward) 成分 - - # clip 座標への正規化 - # cam_coords[:, 0] は right 方向 = clip_x 方向（sx_m でスケール） - # cam_coords[:, 1] は cam_up 方向 = clip_y 方向（sy_m でスケール） - clip_x = cam_coords[:, 0] / sx_m # ∈ [-1, 1] が撮影範囲内 - clip_y = cam_coords[:, 1] / sy_m # ∈ [-1, 1] が撮影範囲内 + # カメラ基底計算（_compute_camera_basis_and_col_row と同一ロジック、DRY） + clip_x, clip_y = _compute_camera_basis_and_col_row(vertices_m, sensor) # clip → 画像ピクセル座標 # clip_x=-1 → col=0 (左端), clip_x=+1 → col=n_cols (右端) @@ -257,3 +358,81 @@ ) return sampled_clipped.astype(np.float32) + + +def compute_orthographic_uv( + vertices_m: np.ndarray, + luminance_shape: tuple[int, int], + sensor: SensorConfig, +) -> np.ndarray: + """orthographic センサ投影で各頂点の UV テクスチャ座標 ∈ [0, 1] を返す純関数． + + `project_luminance_to_vertices` と**同一の投影規約**（look_at 基底 + + ortho_scale mm→m + clip→col/row 変換）で各頂点の浮動小数点ピクセル座標を求め、 + VTK テクスチャ座標（原点: 左下）に変換する． + + ## UV 変換式 + + ピクセル座標から UV への変換（_compute_camera_basis_and_col_row と共有）: + + col_f = (clip_x + 1) / 2 * W # 画像座標: 左端=0, 右端=W + row_f = (1 - clip_y) / 2 * H # 画像座標: 上端=0, 下端=H（Y 反転） + + u = col_f / W # ∈ [0, 1]（画像左=u=0, 右=u=1） + v = 1 - row_f / H # ∈ [0, 1]（VTK 原点は左下=v=0, 上=v=1） + + ## 向きの根拠（SPEC_03「画像↔物理の向き（検証済み）」） + + - 画像右（col 大）= 物理 X+ → u 大 = X+ ✓ + - 画像上（row 小）= 物理 Y+ → v 大（v=1-row/H, row 小で v 大）= Y+ ✓ + - VTK テクスチャ座標は Y 軸が画像とは逆（原点が左下）であるため、 + v = 1 - row_f / H の反転で「画像上 = Y+」と整合する． + + Args: + vertices_m: 頂点配列 (N_v, 3)，m 単位． + luminance_shape: (H, W) 輝度マップの形状（UV 比率の計算に使用）． + sensor: SceneConfig.sensor（orthographic が前提）． + + Returns: + UV テクスチャ座標 (N_v, 2) float32，各行 (u, v) ∈ [0, 1]． + センサ外（範囲外）の頂点は [0, 1] にクランプされる． + + Raises: + ValueError: sensor.type が 'orthographic' でない場合，または + sensor.ortho_scale が None の場合． + """ + h, w = luminance_shape + + # 共通ヘルパで clip_x, clip_y を計算（DRY: project_luminance_to_vertices と同一基底） + clip_x, clip_y = _compute_camera_basis_and_col_row(vertices_m, sensor) + + # clip → 正規化ピクセル座標（0〜1） + # col_f / W = (clip_x + 1) / 2 + u = (clip_x + 1.0) / 2.0 + # row_f / H = (1 - clip_y) / 2 → v = 1 - row_f/H = (1 + clip_y) / 2 + # VTK テクスチャ座標は原点が左下（画像は左上原点）なので v を反転する + # v = 1 - (row_f / H) = 1 - (1 - clip_y) / 2 = (1 + clip_y) / 2 + v = (1.0 + clip_y) / 2.0 + + # 範囲外をクランプ + u = np.clip(u, 0.0, 1.0) + v = np.clip(v, 0.0, 1.0) + + out_of_range = np.sum((clip_x < -1) | (clip_x > 1) | (clip_y < -1) | (clip_y > 1)) + if out_of_range > 0: + _logger.debug( + "UV 算出: 投影範囲外の頂点 %d / %d （[0,1] クランプ済み）", + int(out_of_range), + len(clip_x), + ) + + uv = np.stack([u, v], axis=1).astype(np.float32) + _logger.debug( + "compute_orthographic_uv: shape=%s u=[%.4f, %.4f] v=[%.4f, %.4f]", + uv.shape, + float(u.min()), + float(u.max()), + float(v.min()), + float(v.max()), + ) + return uv diff --git a/src/sm_tias_lightsim/visualize/viewer.py b/src/sm_tias_lightsim/visualize/viewer.py index dac863b..c6e8bc5 100644 --- a/src/sm_tias_lightsim/visualize/viewer.py +++ b/src/sm_tias_lightsim/visualize/viewer.py @@ -11,14 +11,65 @@ 投影規約の詳細は visualize/projection.py の docstring を参照． 投影モードでは: - - 評価板が主役：viridis カラーマップ + scalar bar 1 本（単位: Luminance） + - 評価板が主役：viridis カラーマップ + scalar bar 1 本（単位: Irradiance (W/m²)） + - 輝度マップは E_board = π * luminance_map / ρ で照度 (W/m²) に換算する + （ρ = 評価板材料の拡散反射率、Lambertian 拡散面前提） - 他メッシュは半透明ニュートラル（グレー, opacity=0.2） - 配色は percentile クリップで高ダイナミックレンジ潰れを防止 -## 直接ベイクモード（既存動作） +## ハイブリッドモード（luminance_map + irradiance 同時指定時） -irradiance dict が指定された場合は各メッシュの per-face 照度で着色する（後方互換）． -irradiance の scalar bar は 1 本に統合（重複 scalar bar のバグを解消）． +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 @@ -67,6 +118,12 @@ # 直接ベイクモードで着色メッシュ以外の不透明度 _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 を構築する． @@ -125,9 +182,7 @@ return center, max(diagonal, 1e-6) -def _apply_percentile_clip( - values: np.ndarray, clip_low: float, clip_high: float -) -> np.ndarray: +def _apply_percentile_clip(values: np.ndarray, clip_low: float, clip_high: float) -> np.ndarray: """percentile クリップを適用して高 DR 潰れを防ぐ． Args: @@ -143,17 +198,162 @@ 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]: - """投影モード用に評価板 id とper-vertex 輝度スカラを準備する． +) -> tuple[str | None, np.ndarray | None, np.ndarray | None, np.ndarray | None]: + """投影モード用に評価板 id・per-vertex 輝度スカラ・UV 座標・カメラ向き face マスクを準備する． 評価板メッシュを特定して STL をロードし、orthographic 投影で - per-vertex 輝度スカラ配列を計算して返す． + per-vertex 輝度スカラ配列と UV テクスチャ座標を計算して返す． + また、各 face がカメラ（センサ）に面しているかを判定する bool マスクも返す． Args: scene_config: 検証済み SceneConfig． @@ -163,10 +363,15 @@ clip_high: percentile クリップの上限（%）． Returns: - (eval_board_id, projected_scalars) のタプル． - 失敗時は (None, None) を返す（例外は投げない）． + (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, ) @@ -180,6 +385,13 @@ 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 算出に使用） + if luminance_map.ndim == 3: + lum_shape = (luminance_map.shape[0], luminance_map.shape[1]) + else: + lum_shape = (luminance_map.shape[0], luminance_map.shape[1]) + projected_scalars = project_luminance_to_vertices( eval_scaled.vertices, luminance_map, @@ -187,17 +399,84 @@ 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 + return None, None, None, None - return eval_board_id, projected_scalars + 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( @@ -210,20 +489,31 @@ 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", ) -> None: """PyVista でシーンとベイク結果を表示する． メッシュ・LED・センサ・座標軸を含む 3D インタラクティブビューアを開く． 表示モードの優先順位: - 1. luminance_map が指定された場合（投影モード）: + 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）． - 2. irradiance が指定された場合（直接ベイクモード）: - 各メッシュを per-face 照度で着色（viridis）． - scalar bar は 1 本に統合（旧実装の重複バグを解消）． - 3. 両方 None の場合: シーンレイアウトのみ（--no-bake 相当）． + bake_opacity は影響しない（投影モード専用の透明度制御がある）． + 4. 両方 None の場合: シーンレイアウトのみ（--no-bake 相当）． off_screen=True のときは GUI ウィンドウを開かず，screenshot が指定されていれば保存する． screenshot=None かつ off_screen=True のときは何も出力しない（no-op）． @@ -239,31 +529,223 @@ 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）には影響しない． """ 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) - # 投影モードか否かを決定 - use_projection = luminance_map is not None + # ベイクモード / ハイブリッドモード時に 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) - # 投影モードの場合：評価板メッシュ id と per-vertex スカラを準備する + # モード判定 + # 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 = _prepare_projection_scalars( - scene_config, project_root, luminance_map, clip_low, clip_high # type: ignore[arg-type] + 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)" + ) + + # ---- 共有 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] + # 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 を追加 + for irr in irradiance.values(): + if len(irr) > 0: + _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_added = False # scalar bar を 1 本だけ追加するフラグ + # 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: try: @@ -278,24 +760,254 @@ polydata = _build_pyvista_polydata(scaled.vertices, scaled.faces) if use_projection and mesh_cfg.id == eval_board_id and projected_scalars is not None: - # 投影モード: 評価板を per-vertex 輝度で着色（viridis, 知覚均等） - # point_data に格納して per-vertex スカラとして扱う - polydata.point_data["luminance"] = projected_scalars + # ハイブリッドモード（--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] - show_bar = not scalar_bar_added - plotter.add_mesh( - polydata, - scalars="luminance", - cmap="viridis", - show_scalar_bar=show_bar, - scalar_bar_args={"title": "Luminance (a.u.)"}, - label=mesh_cfg.id, - ) + # ---- 内側 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) + 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: - scalar_bar_added = True + bake_scalar_bar_added = True elif use_projection: - # 投影モード: 評価板以外は半透明ニュートラルグレー（背景扱い） + # 投影モード（ハイブリッドでない）または + # ハイブリッドモードで irradiance に含まれないメッシュ: + # 評価板以外は半透明ニュートラルグレー（背景扱い） plotter.add_mesh( polydata, color="lightgray", @@ -303,27 +1015,8 @@ label=mesh_cfg.id, ) - elif irradiance is not None and mesh_cfg.id in irradiance: - # 直接ベイクモード: per-face 照度で着色 - irr = irradiance[mesh_cfg.id] - # percentile クリップを適用 - irr_clipped = _apply_percentile_clip(irr.astype(np.float32), clip_low, clip_high) - polydata.cell_data["irradiance"] = irr_clipped - - show_bar = not scalar_bar_added - plotter.add_mesh( - polydata, - scalars="irradiance", - cmap="viridis", - show_scalar_bar=show_bar, - scalar_bar_args={"title": "Irradiance (W/m²)"}, - label=mesh_cfg.id, - ) - if show_bar: - scalar_bar_added = True - else: - # 着色なし: グレー半透明 + # 着色なし: グレー半透明（--no-bake または bake 未完了メッシュ） plotter.add_mesh( polydata, color="lightgray", diff --git a/tests/cli/test_visualize_cli.py b/tests/cli/test_visualize_cli.py index 9d1457a..35f5012 100644 --- a/tests/cli/test_visualize_cli.py +++ b/tests/cli/test_visualize_cli.py @@ -267,3 +267,252 @@ "--off-screen", ]) assert result == 0, "no-op でも正常終了すること" + + +# --------------------------------------------------------------------------- +# 9. 新引数のパース検証（argparse 層、Mitsuba 不要） +# --------------------------------------------------------------------------- + + +class TestNewArgParsing: + """新規追加引数のパース仕様ベーステスト（Phase 2 で追加された引数）． + + 仕様（cli/visualize.py _parse_args）: + --bake-mode choices=["direct", "path"] default="direct" + --bake-samples type=int default=64 + --bake-cache type=Path default=None + --opacity type=float default=0.5 + --hide-below type=float default=0.0 + --bake-smooth type=int default=4 + --bake-scale choices=["linear", "log"] default="log" + """ + + def test_bake_mode_default_is_direct(self): + """--bake-mode の既定値が "direct" であること．""" + from sm_tias_lightsim.cli.visualize import _parse_args + args = _parse_args(["--scene", "scene.yaml"]) + assert args.bake_mode == "direct" + + def test_bake_mode_path_is_accepted(self): + """--bake-mode path が受け付けられること．""" + from sm_tias_lightsim.cli.visualize import _parse_args + args = _parse_args(["--scene", "scene.yaml", "--bake-mode", "path"]) + assert args.bake_mode == "path" + + def test_bake_mode_invalid_raises_system_exit(self): + """--bake-mode に不正値を渡すと SystemExit が発生すること（choices バリデーション）．""" + from sm_tias_lightsim.cli.visualize import _parse_args + with pytest.raises(SystemExit) as exc_info: + _parse_args(["--scene", "scene.yaml", "--bake-mode", "invalid"]) + assert exc_info.value.code != 0 + + def test_bake_samples_default_is_64(self): + """--bake-samples の既定値が 64 であること．""" + from sm_tias_lightsim.cli.visualize import _parse_args + args = _parse_args(["--scene", "scene.yaml"]) + assert args.bake_samples == 64 + + def test_bake_samples_custom_value(self): + """--bake-samples 256 が正しくパースされること．""" + from sm_tias_lightsim.cli.visualize import _parse_args + args = _parse_args(["--scene", "scene.yaml", "--bake-samples", "256"]) + assert args.bake_samples == 256 + + def test_bake_cache_default_is_none(self): + """--bake-cache の既定値が None であること．""" + from sm_tias_lightsim.cli.visualize import _parse_args + args = _parse_args(["--scene", "scene.yaml"]) + assert args.bake_cache is None + + def test_bake_cache_path_is_accepted(self, tmp_path): + """--bake-cache PATH が Path 型でパースされること．""" + from sm_tias_lightsim.cli.visualize import _parse_args + cache_path = tmp_path / "bake_cache.npz" + args = _parse_args(["--scene", "scene.yaml", "--bake-cache", str(cache_path)]) + assert args.bake_cache == cache_path + + def test_opacity_default_is_05(self): + """--opacity の既定値が 0.5 であること．""" + from sm_tias_lightsim.cli.visualize import _parse_args + args = _parse_args(["--scene", "scene.yaml"]) + assert args.opacity == pytest.approx(0.5) + + def test_opacity_custom_value(self): + """--opacity 0.8 が float でパースされること．""" + from sm_tias_lightsim.cli.visualize import _parse_args + args = _parse_args(["--scene", "scene.yaml", "--opacity", "0.8"]) + assert args.opacity == pytest.approx(0.8) + + def test_hide_below_default_is_0(self): + """--hide-below の既定値が 0.0 であること．""" + from sm_tias_lightsim.cli.visualize import _parse_args + args = _parse_args(["--scene", "scene.yaml"]) + assert args.hide_below == pytest.approx(0.0) + + def test_hide_below_negative_value(self): + """--hide-below -1.0 が負の float でパースされること（全面表示モード）．""" + from sm_tias_lightsim.cli.visualize import _parse_args + args = _parse_args(["--scene", "scene.yaml", "--hide-below", "-1.0"]) + assert args.hide_below == pytest.approx(-1.0) + + def test_bake_smooth_default_is_4(self): + """--bake-smooth の既定値が 4 であること．""" + from sm_tias_lightsim.cli.visualize import _parse_args + args = _parse_args(["--scene", "scene.yaml"]) + assert args.bake_smooth == 4 + + def test_bake_smooth_zero(self): + """--bake-smooth 0 がパースされること（平滑化なし）．""" + from sm_tias_lightsim.cli.visualize import _parse_args + args = _parse_args(["--scene", "scene.yaml", "--bake-smooth", "0"]) + assert args.bake_smooth == 0 + + def test_bake_scale_default_is_log(self): + """--bake-scale の既定値が "log" であること．""" + from sm_tias_lightsim.cli.visualize import _parse_args + args = _parse_args(["--scene", "scene.yaml"]) + assert args.bake_scale == "log" + + def test_bake_scale_linear_is_accepted(self): + """--bake-scale linear が受け付けられること．""" + from sm_tias_lightsim.cli.visualize import _parse_args + args = _parse_args(["--scene", "scene.yaml", "--bake-scale", "linear"]) + assert args.bake_scale == "linear" + + def test_bake_scale_invalid_raises_system_exit(self): + """--bake-scale に不正値を渡すと SystemExit が発生すること．""" + from sm_tias_lightsim.cli.visualize import _parse_args + with pytest.raises(SystemExit) as exc_info: + _parse_args(["--scene", "scene.yaml", "--bake-scale", "gamma"]) + assert exc_info.value.code != 0 + + +# --------------------------------------------------------------------------- +# 10. is_hybrid / no_bake ロジック（引数パース層の純論理テスト） +# --------------------------------------------------------------------------- + + +class TestIsHybridAndNoBakeLogic: + """is_hybrid と no_bake の計算ロジックを検証する． + + 仕様（cli/visualize.py main）: + is_hybrid = (render_path is not None) and (bake_mode == "path") + no_bake = args.no_bake or (render_path is not None and not is_hybrid) + + つまり: + --render なし + bake_mode=direct → is_hybrid=False, no_bake=False（全面直接ベイク） + --render なし + bake_mode=path → is_hybrid=False, no_bake=False（全面 path ベイク） + --render あり + bake_mode=direct → is_hybrid=False, no_bake=True（投影のみ） + --render あり + bake_mode=path → is_hybrid=True, no_bake=False（ハイブリッド） + --no-bake 指定 → no_bake=True（常に） + """ + + def _compute_hybrid_no_bake(self, render_path, bake_mode, explicit_no_bake=False): + """main() の is_hybrid / no_bake 計算をテスト用に再現する．""" + is_hybrid = (render_path is not None) and (bake_mode == "path") + no_bake = explicit_no_bake or (render_path is not None and not is_hybrid) + return is_hybrid, no_bake + + def test_no_render_direct_is_not_hybrid_not_no_bake(self): + """--render なし + direct: is_hybrid=False, no_bake=False（全面ベイク）．""" + is_hybrid, no_bake = self._compute_hybrid_no_bake(None, "direct") + assert is_hybrid is False + assert no_bake is False + + def test_no_render_path_is_not_hybrid_not_no_bake(self): + """--render なし + path: is_hybrid=False, no_bake=False（全面 path ベイク）．""" + is_hybrid, no_bake = self._compute_hybrid_no_bake(None, "path") + assert is_hybrid is False + assert no_bake is False + + def test_render_direct_is_not_hybrid_but_no_bake(self, tmp_path): + """--render あり + direct: is_hybrid=False, no_bake=True（投影のみ）． + + 仕様: --render + --bake-mode direct → ベイクしない（投影のみ） + """ + render_path = tmp_path / "lum.npy" + is_hybrid, no_bake = self._compute_hybrid_no_bake(render_path, "direct") + assert is_hybrid is False + assert no_bake is True + + def test_render_path_is_hybrid_not_no_bake(self, tmp_path): + """--render あり + path: is_hybrid=True, no_bake=False（ハイブリッドモード）． + + 仕様: --render + --bake-mode path → ハイブリッドモード（評価板=投影・壁=ベイク） + """ + render_path = tmp_path / "lum.npy" + is_hybrid, no_bake = self._compute_hybrid_no_bake(render_path, "path") + assert is_hybrid is True + assert no_bake is False + + def test_explicit_no_bake_overrides_all(self, tmp_path): + """--no-bake 指定時は常に no_bake=True になること．""" + render_path = tmp_path / "lum.npy" + # --render + path でも --no-bake があれば no_bake=True + _, no_bake = self._compute_hybrid_no_bake(render_path, "path", explicit_no_bake=True) + assert no_bake is True + + +# --------------------------------------------------------------------------- +# 11. --bake-cache 読み書きロジック（純ロジック・argparse 層） +# --------------------------------------------------------------------------- + + +class TestBakeCacheParsing: + """--bake-cache の引数パース仕様テスト． + + 仕様（cli/visualize.py）: + --bake-cache PATH: 存在すれば読込（Mitsuba 起動なし）・なければ計算後保存 + --bake-mode path のときのみ有効（direct では無視） + """ + + def test_bake_cache_none_by_default(self): + """--bake-cache を省略した場合 None になること．""" + from sm_tias_lightsim.cli.visualize import _parse_args + args = _parse_args(["--scene", "scene.yaml"]) + assert args.bake_cache is None + + def test_bake_cache_existing_file_is_loaded(self, tmp_path): + """--bake-cache に存在する npz パスを指定すると読込（ベイク再計算なし）のロジックが動くこと． + + 実際にキャッシュ読込が行われることは main() レベルで確認する必要があるが、 + ここでは読込が行われる前提条件（bake_mode=path かつ bake_cache_path が存在する）の + パース層確認に留める（Mitsuba 依存を避けるため）． + """ + from sm_tias_lightsim.cli.visualize import _parse_args + + # 有効な npz ファイルを作成 + import numpy as np + cache_path = tmp_path / "cache.npz" + np.savez(str(cache_path), mesh_a=np.zeros(10, dtype=np.float32)) + + args = _parse_args([ + "--scene", "scene.yaml", + "--bake-mode", "path", + "--bake-cache", str(cache_path), + ]) + assert args.bake_cache == cache_path + assert args.bake_mode == "path" + + def test_bake_cache_invalid_npz_is_handled_gracefully(self, tmp_path, capsys): + """--bake-cache に不正な npz を指定すると警告して再計算にフォールバックすること． + + 仕様（cli/visualize.py）: + キャッシュの読み込みに失敗した場合は警告して再計算にフォールバックする + """ + # 不正なファイル（非 npz）を作成 + invalid_cache = tmp_path / "invalid.npz" + invalid_cache.write_bytes(b"not a npz file content") + + # main() を呼ぶと YAML が存在しないので return 1 になるが、 + # ここでは不正 npz の警告メッセージが stderr に出ることを確認する． + # 最小 YAML が存在しない場合は return 1（YAML エラー）で止まるため + # キャッシュ読込の副作用のみチェックが困難 → 純パーズ層のみ確認 + from sm_tias_lightsim.cli.visualize import _parse_args + args = _parse_args([ + "--scene", "scene.yaml", + "--bake-mode", "path", + "--bake-cache", str(invalid_cache), + ]) + # パース自体は成功する + assert args.bake_cache == invalid_cache diff --git a/tests/visualize/test_baker.py b/tests/visualize/test_baker.py index 15b4f3c..2b5d98c 100644 --- a/tests/visualize/test_baker.py +++ b/tests/visualize/test_baker.py @@ -399,22 +399,43 @@ # --------------------------------------------------------------------------- -# 5. mode = "path" で NotImplementedError が発生すること +# 5. mode バリデーション # --------------------------------------------------------------------------- -def test_unsupported_mode_raises_not_implemented_error( +def test_invalid_mode_raises_value_error( point_light_scene_config: tuple[SceneConfig, Path], ): - """mode='path' を指定すると NotImplementedError が raise されること． + """不正な mode 文字列を渡すと ValueError が raise されること． - 仕様: mode != "direct" で NotImplementedError（baker.py bake_irradiance） + 仕様（baker.py bake_irradiance）: + mode が "direct" でも "path" でもない場合 ValueError を raise する． Mitsuba をロードしないため @pytest.mark.slow は付けない． """ config, project_root = point_light_scene_config - with pytest.raises(NotImplementedError): - bake_irradiance(config, project_root, mode="path") # type: ignore[arg-type] + with pytest.raises(ValueError, match="mode="): + bake_irradiance(config, project_root, mode="invalid") # type: ignore[arg-type] + + +def test_valid_modes_do_not_raise_on_mode_check( + point_light_scene_config: tuple[SceneConfig, Path], +): + """mode="direct" と mode="path" は ValueError を raise しないこと（mode チェック層）． + + 仕様: mode は "direct" または "path" のみ有効（ValueError は不正値のみ）． + この関数は Mitsuba ロードが必要なため slow マーカーを付ける． + """ + # "direct" は既存テスト（test_bake_irradiance_returns_dict_of_float32_arrays）でカバー済み． + # ここでは ValueError が mode チェック段階でのみ発生することを確認する． + config, project_root = point_light_scene_config + # "direct" で ValueError が出ないことを確認（正常呼び出し — 結果は別テストで検証） + import pytest as _pytest + with _pytest.raises(Exception) as exc_info: + bake_irradiance(config, project_root, mode="invalid_xyz") # type: ignore[arg-type] + assert isinstance(exc_info.value, ValueError), ( + f"mode バリデーションは ValueError であること: got {type(exc_info.value)}" + ) # --------------------------------------------------------------------------- @@ -478,3 +499,89 @@ for mesh_id, irr in result.items(): assert np.all(irr >= 0.0), f"{mesh_id}: 照度は非負であること" + + +# --------------------------------------------------------------------------- +# 8. exclude_mesh_ids — 除外されたメッシュが戻り値に含まれないこと +# --------------------------------------------------------------------------- + + +@pytest.mark.slow +def test_exclude_mesh_ids_removes_mesh_from_result( + tmp_path: Path, +): + """exclude_mesh_ids に指定したメッシュ ID が戻り値の辞書に含まれないこと． + + 仕様（baker.py bake_irradiance）: + exclude_mesh_ids に指定された id はキーに含まれない． + 2 メッシュのシーンで 1 つを除外し、除外した id が result に入っていないことを検証する． + """ + # 2 つのメッシュを用意する + verts = np.array( + [[0.0, 0.0, 0.0], [10.0, 0.0, 0.0], [10.0, 10.0, 0.0]], dtype=np.float64 + ) + faces = np.array([[0, 1, 2]], dtype=np.int64) + + stl_a = tmp_path / "mesh_a.stl" + stl_b = tmp_path / "mesh_b.stl" + mesh = trimesh.Trimesh(vertices=verts, faces=faces, process=False) + mesh.export(str(stl_a)) + mesh.export(str(stl_b)) + + config = _make_scene_config_with_meshes( + mesh_entries=[ + {"id": "mesh_a", "path": str(stl_a), "unit": "mm", "material": "white"}, + {"id": "mesh_b", "path": str(stl_b), "unit": "mm", "material": "white"}, + ], + light_dict={ + "id": "led", + "type": "point", + "position": [5.0, 5.0, 100.0], + "intensity": 1.0, + "profile": "lambertian", + }, + ) + + # "mesh_b" を除外 + result = bake_irradiance(config, tmp_path, exclude_mesh_ids={"mesh_b"}) + + assert "mesh_a" in result, "除外していないメッシュは戻り値に含まれること" + assert "mesh_b" not in result, "exclude_mesh_ids に指定したメッシュは戻り値に含まれないこと" + + +@pytest.mark.slow +def test_exclude_mesh_ids_empty_set_does_not_exclude_anything( + point_light_scene_config: tuple[SceneConfig, Path], +): + """exclude_mesh_ids=set()（空集合）のとき全メッシュが戻り値に含まれること． + + 仕様（baker.py）: exclude_mesh_ids が空の場合は全メッシュを処理する． + """ + config, project_root = point_light_scene_config + + result_all = bake_irradiance(config, project_root, exclude_mesh_ids=set()) + result_no_exclude = bake_irradiance(config, project_root) + + assert set(result_all.keys()) == set(result_no_exclude.keys()), ( + "exclude_mesh_ids=set() は除外なしと同一のキーセットを返すこと" + ) + + +@pytest.mark.slow +def test_exclude_mesh_ids_none_behaves_same_as_empty_set( + point_light_scene_config: tuple[SceneConfig, Path], +): + """exclude_mesh_ids=None のとき全メッシュが戻り値に含まれること（None は空集合と等価）． + + 仕様（baker.py）: + if exclude_mesh_ids is None: + exclude_mesh_ids = set() + """ + config, project_root = point_light_scene_config + + result_none = bake_irradiance(config, project_root, exclude_mesh_ids=None) + expected_ids = {m.id for m in config.geometry.meshes} + + assert set(result_none.keys()) == expected_ids, ( + "exclude_mesh_ids=None は全メッシュを返すこと（空集合と等価）" + ) diff --git a/tests/visualize/test_projection.py b/tests/visualize/test_projection.py index 83e4277..bdecdf9 100644 --- a/tests/visualize/test_projection.py +++ b/tests/visualize/test_projection.py @@ -33,6 +33,8 @@ SensorConfig, ) from sm_tias_lightsim.visualize.projection import ( + compute_face_camera_mask, + compute_orthographic_uv, find_eval_board_mesh_id, project_luminance_to_vertices, ) @@ -914,3 +916,327 @@ clip_high=95.0, ) assert screenshot_path.exists() + + +# =========================================================================== +# 9. compute_orthographic_uv — UV テクスチャ座標の仕様検証 +# =========================================================================== + + +class TestComputeOrthographicUv: + """compute_orthographic_uv の仕様ベーステスト． + + 仕様（projection.py docstring）: + u = (clip_x + 1) / 2 ∈ [0, 1]（画像左=u=0, 右=u=1） + v = (1 + clip_y) / 2 ∈ [0, 1]（VTK 原点は左下=v=0, 上=v=1） + + SPEC_03「画像↔物理の向き（検証済み）」: + 画像右 = 物理 X+ → u 大 = X+ + 画像上 = 物理 Y+ → v 大 = Y+（VTK の v=1-row/H であるため Y+ が v 大） + """ + + @pytest.fixture(autouse=True) + def setup_sensor(self): + """SPEC_03 準拠の baseline センサを設定する．""" + self.sensor = _make_baseline_sensor() + self.sx_m = self.sensor.ortho_scale[0] * 0.001 # 0.05 + self.sy_m = self.sensor.ortho_scale[1] * 0.001 # 0.052 + self.lum_shape = (512, 512) + + def test_returns_float32_uv_array(self): + """戻り値が (N_v, 2) float32 配列であること． + + 仕様: UV テクスチャ座標 (N_v, 2) float32 + """ + vertices_m = np.array([[0.0, 0.0, 0.0]], dtype=np.float64) + uv = compute_orthographic_uv(vertices_m, self.lum_shape, self.sensor) + assert isinstance(uv, np.ndarray) + assert uv.dtype == np.float32 + assert uv.shape == (1, 2) + + def test_center_vertex_maps_to_uv_05_05(self): + """ワールド原点 (0,0,0) が UV = (0.5, 0.5)（中心）に写ること． + + 仕様: clip_x=0 → u=(0+1)/2=0.5, clip_y=0 → v=(1+0)/2=0.5 + """ + vertices_m = np.array([[0.0, 0.0, 0.0]], dtype=np.float64) + uv = compute_orthographic_uv(vertices_m, self.lum_shape, self.sensor) + assert float(uv[0, 0]) == pytest.approx(0.5, abs=1e-5), "u=0.5（中心）" + assert float(uv[0, 1]) == pytest.approx(0.5, abs=1e-5), "v=0.5（中心）" + + def test_positive_x_vertex_maps_to_u_larger_than_05(self): + """物理 X+ (world_x > 0) が u > 0.5 に写ること． + + SPEC_03: 画像右 = 物理 X+ → u 大 = X+ + """ + vertices_m = np.array([[self.sx_m * 0.5, 0.0, 0.0]], dtype=np.float64) + uv = compute_orthographic_uv(vertices_m, self.lum_shape, self.sensor) + assert float(uv[0, 0]) > 0.5, f"X+ の頂点は u > 0.5 であること: u={float(uv[0,0]):.4f}" + + def test_positive_y_vertex_maps_to_v_larger_than_05(self): + """物理 Y+ (world_y > 0) が v > 0.5 に写ること． + + SPEC_03: 画像上 = 物理 Y+, VTK v=1 が上 → Y+ で v 大 + """ + vertices_m = np.array([[0.0, self.sy_m * 0.5, 0.0]], dtype=np.float64) + uv = compute_orthographic_uv(vertices_m, self.lum_shape, self.sensor) + assert float(uv[0, 1]) > 0.5, f"Y+ の頂点は v > 0.5 であること: v={float(uv[0,1]):.4f}" + + def test_x_plus_boundary_maps_to_u_1(self): + """物理 X+ 端 (world_x = +sx_m) が u=1.0 に写ること． + + 仕様: clip_x=+1 → u=(1+1)/2=1.0 → クランプで 1.0 固定 + """ + vertices_m = np.array([[self.sx_m, 0.0, 0.0]], dtype=np.float64) + uv = compute_orthographic_uv(vertices_m, self.lum_shape, self.sensor) + assert float(uv[0, 0]) == pytest.approx(1.0, abs=1e-5), "X+ 端は u=1.0" + + def test_x_minus_boundary_maps_to_u_0(self): + """物理 X- 端 (world_x = -sx_m) が u=0.0 に写ること． + + 仕様: clip_x=-1 → u=(-1+1)/2=0.0 + """ + vertices_m = np.array([[-self.sx_m, 0.0, 0.0]], dtype=np.float64) + uv = compute_orthographic_uv(vertices_m, self.lum_shape, self.sensor) + assert float(uv[0, 0]) == pytest.approx(0.0, abs=1e-5), "X- 端は u=0.0" + + def test_y_plus_boundary_maps_to_v_1(self): + """物理 Y+ 端 (world_y = +sy_m) が v=1.0 に写ること． + + 仕様: clip_y=+1 → v=(1+1)/2=1.0 + """ + vertices_m = np.array([[0.0, self.sy_m, 0.0]], dtype=np.float64) + uv = compute_orthographic_uv(vertices_m, self.lum_shape, self.sensor) + assert float(uv[0, 1]) == pytest.approx(1.0, abs=1e-5), "Y+ 端は v=1.0" + + def test_y_minus_boundary_maps_to_v_0(self): + """物理 Y- 端 (world_y = -sy_m) が v=0.0 に写ること． + + 仕様: clip_y=-1 → v=(1-1)/2=0.0 + """ + vertices_m = np.array([[0.0, -self.sy_m, 0.0]], dtype=np.float64) + uv = compute_orthographic_uv(vertices_m, self.lum_shape, self.sensor) + assert float(uv[0, 1]) == pytest.approx(0.0, abs=1e-5), "Y- 端は v=0.0" + + def test_uv_range_in_0_1_for_in_range_vertices(self): + """センサ範囲内の全頂点の UV が [0, 1] に収まること． + + 仕様: UV テクスチャ座標 ∈ [0, 1]（センサ外は [0,1] クランプ） + """ + rng = np.random.default_rng(42) + n = 100 + xs = rng.uniform(-self.sx_m, self.sx_m, n) + ys = rng.uniform(-self.sy_m, self.sy_m, n) + zs = np.zeros(n) + vertices_m = np.stack([xs, ys, zs], axis=1) + uv = compute_orthographic_uv(vertices_m, self.lum_shape, self.sensor) + assert np.all(uv >= 0.0), "UV の全要素が 0.0 以上であること" + assert np.all(uv <= 1.0), "UV の全要素が 1.0 以下であること" + + def test_out_of_range_vertices_are_clamped_to_0_1(self): + """センサ範囲外の頂点が [0, 1] にクランプされること（例外なし）． + + 仕様: センサ外（範囲外）の頂点は [0, 1] にクランプされる + """ + far_vertices = np.array([ + [self.sx_m * 3.0, self.sy_m * 3.0, 0.0], + [-self.sx_m * 3.0, -self.sy_m * 3.0, 0.0], + ], dtype=np.float64) + uv = compute_orthographic_uv(far_vertices, self.lum_shape, self.sensor) + assert np.all(uv >= 0.0) and np.all(uv <= 1.0), ( + "範囲外頂点の UV が [0, 1] にクランプされること" + ) + + def test_uv_consistent_with_project_luminance_col_row_convention(self): + """compute_orthographic_uv と project_luminance_to_vertices が共通の投影規約を使うこと． + + SPEC_03 規約: clip_x = world_x / sx_m, clip_y = world_y / sy_m + u = (clip_x + 1) / 2 と col_f / W = (clip_x + 1) / 2 は同値． + v = (clip_y + 1) / 2 と 1 - row_f / H = (1 + clip_y) / 2 は同値． + """ + H, W = 64, 64 + sensor = _make_baseline_sensor(width=W, height=H) + sx_m = sensor.ortho_scale[0] * 0.001 + sy_m = sensor.ortho_scale[1] * 0.001 + + test_points = np.array([ + [0.0, 0.0, 0.0], + [sx_m * 0.5, 0.0, 0.0], + [0.0, sy_m * 0.5, 0.0], + [-sx_m * 0.5, -sy_m * 0.5, 0.0], + ], dtype=np.float64) + + uniform_map = np.ones((H, W), dtype=np.float64) + + uv = compute_orthographic_uv(test_points, (H, W), sensor) + proj = project_luminance_to_vertices( + test_points, uniform_map, sensor, clip_low=0.0, clip_high=100.0 + ) + + assert np.all(uv >= 0.0) and np.all(uv <= 1.0) + np.testing.assert_allclose( + proj, np.ones(len(test_points), dtype=np.float32), + atol=1e-4, + err_msg="uniform_map での投影値は 1.0 であること（共通基底の確認）", + ) + + +# =========================================================================== +# 10. compute_face_camera_mask — 幾何位置ベース face 判定の仕様検証 +# =========================================================================== + + +class TestComputeFaceCameraMask: + """compute_face_camera_mask の仕様ベーステスト． + + 仕様（projection.py docstring）: + face centroid の view_dir 方向射影値が「proj_min + tol_m 以内」の face を True とする． + baseline: sensor が -Z から +Z を向く → view_dir ≈ (0,0,1)、proj ≈ world_z． + 評価プレート（Z=-4.5mm = -0.0045m）は proj_min に近く True になる． + 外側 AR マーカー等（Z > -4.5mm）は False になる． + STL 巻き順・法線符号に非依存（幾何位置ベース）． + """ + + @pytest.fixture(autouse=True) + def setup_baseline_sensor(self): + """SPEC_03 baseline センサを設定する（-Z から +Z を向く）．""" + self.sensor = _make_baseline_sensor( + position=(0.0, 0.0, -50.0), + target=(0.0, 0.0, 0.0), + ) + + def test_inner_face_at_z_min_is_true(self): + """Z_min 端（センサ側・内側面）の face が True になること． + + 仕様: view_dir=(0,0,1)のとき proj_min は最小 Z 端． + その面の face centroid は proj_min + tol_m 以内 → True． + """ + verts = np.array([ + [0.0, 0.0, -0.005], # v0 inner + [0.01, 0.0, -0.005], # v1 inner + [0.01, 0.01, -0.005], # v2 inner + [0.0, 0.0, 0.005], # v3 outer + [0.01, 0.0, 0.005], # v4 outer + [0.01, 0.01, 0.005], # v5 outer + ], dtype=np.float64) + faces = np.array([ + [0, 1, 2], # inner face (Z=-5mm) + [3, 4, 5], # outer face (Z=+5mm) + ], dtype=np.int64) + + mask = compute_face_camera_mask(verts, faces, self.sensor) + assert mask.shape == (2,) + assert bool(mask[0]) is True, "Z_min 端の face は True（カメラ側）" + assert bool(mask[1]) is False, "Z_max 端の face は False（外側）" + + def test_all_faces_same_z_all_true(self): + """全 face が同一 Z のとき（均一平板）全 face が True になること． + + 仕様: proj_min = proj_max のとき、全 face centroid が proj_min + tol_m 以内 → 全 True + """ + verts = np.array([ + [0.0, 0.0, -0.005], + [0.01, 0.0, -0.005], + [0.01, 0.01, -0.005], + [0.0, 0.01, -0.005], + ], dtype=np.float64) + faces = np.array([ + [0, 1, 2], + [0, 2, 3], + ], dtype=np.int64) + + mask = compute_face_camera_mask(verts, faces, self.sensor) + assert np.all(mask), "全面同一 Z の場合は全 face が True" + + def test_mask_is_independent_of_winding_order(self): + """face の巻き順が逆でも mask 結果が変わらないこと（巻き順非依存）． + + 仕様: STL の巻き順は作者依存で信頼できないため、face 法線の内積による判定をやめ、 + face centroid の位置ベースで判定する． + """ + all_verts = np.array([ + [0.0, 0.0, -0.005], + [0.01, 0.0, -0.005], + [0.01, 0.01, -0.005], + [0.0, 0.0, 0.005], + [0.01, 0.0, 0.005], + [0.01, 0.01, 0.005], + ], dtype=np.float64) + + faces_cw = np.array([[0, 1, 2], [3, 4, 5]], dtype=np.int64) # 正順 + faces_ccw = np.array([[0, 2, 1], [3, 5, 4]], dtype=np.int64) # 逆順 + + mask_cw = compute_face_camera_mask(all_verts, faces_cw, self.sensor) + mask_ccw = compute_face_camera_mask(all_verts, faces_ccw, self.sensor) + + np.testing.assert_array_equal( + mask_cw, mask_ccw, + err_msg="巻き順を逆にしても mask 結果が変わらないこと（幾何位置ベース）" + ) + + def test_tol_m_controls_threshold_width(self): + """tol_m の値が閾値幅を制御すること． + + 仕様: face centroid の proj が proj_min + tol_m 以下の face が True． + """ + # 3 層：Z=-5mm（最内）, Z=-3mm（中間）, Z=+5mm（外側） + verts = np.array([ + [0.0, 0.0, -0.005], # inner + [0.01, 0.0, -0.005], + [0.01, 0.01, -0.005], + [0.0, 0.0, -0.003], # middle + [0.01, 0.0, -0.003], + [0.01, 0.01, -0.003], + [0.0, 0.0, 0.005], # outer + [0.01, 0.0, 0.005], + [0.01, 0.01, 0.005], + ], dtype=np.float64) + faces = np.array([ + [0, 1, 2], # Z=-5mm + [3, 4, 5], # Z=-3mm + [6, 7, 8], # Z=+5mm + ], dtype=np.int64) + + mask_tight = compute_face_camera_mask(verts, faces, self.sensor, tol_m=0.0005) + mask_loose = compute_face_camera_mask(verts, faces, self.sensor, tol_m=0.003) + + assert int(mask_tight.sum()) <= int(mask_loose.sum()), ( + "tol_m が小さいほど True の face 数が少ない（または同じ）こと" + ) + assert bool(mask_tight[0]) is True, "Z_min 端の face は常に True" + assert bool(mask_loose[2]) is False, "Z_max 端の face は tol_m=3mm でも False" + + def test_returns_bool_array_of_correct_shape(self): + """戻り値が (N_f,) bool 配列であること． + + 仕様: bool 配列 (N_f,) + """ + verts = np.array([ + [0.0, 0.0, 0.0], + [0.01, 0.0, 0.0], + [0.01, 0.01, 0.0], + ], dtype=np.float64) + faces = np.array([[0, 1, 2]], dtype=np.int64) + + mask = compute_face_camera_mask(verts, faces, self.sensor) + assert mask.dtype == bool or mask.dtype == np.bool_, "dtype は bool であること" + assert mask.shape == (1,) + + def test_position_target_identical_raises_value_error(self): + """position == target のとき ValueError が発生すること． + + 仕様: sensor position と target が一致している場合 ValueError + """ + sensor = _make_baseline_sensor( + position=(0.0, 0.0, 0.0), + target=(0.0, 0.0, 0.0), + ) + verts = np.array([ + [0.0, 0.0, 0.0], + [0.01, 0.0, 0.0], + [0.01, 0.01, 0.0], + ], dtype=np.float64) + faces = np.array([[0, 1, 2]], dtype=np.int64) + + with pytest.raises(ValueError): + compute_face_camera_mask(verts, faces, sensor) diff --git a/tests/visualize/test_viewer.py b/tests/visualize/test_viewer.py index 8a65793..a05afbf 100644 --- a/tests/visualize/test_viewer.py +++ b/tests/visualize/test_viewer.py @@ -192,3 +192,275 @@ ) assert screenshot_path.exists(), "不正な mesh_id でも例外を投げず screenshot が生成されること" + + +# --------------------------------------------------------------------------- +# 6. bake_opacity クランプ — [0, 1] に制限されること（純ロジック） +# --------------------------------------------------------------------------- + + +class TestBakeOpacityClamp: + """show_scene の bake_opacity クランプ仕様を検証する（純ロジック・引数チェック）． + + 仕様（viewer.py show_scene）: + bake_opacity = max(0.0, min(1.0, bake_opacity)) + 0.0 より小さいと 0.0 に、1.0 より大きいと 1.0 にクランプする． + """ + + @pytest.mark.slow + def test_bake_opacity_above_1_is_clamped( + self, + tmp_path: Path, + minimal_scene_config: tuple[SceneConfig, Path], + ): + """bake_opacity > 1.0 を渡しても例外なく正常終了すること（1.0 にクランプ）． + + 仕様: bake_opacity = max(0.0, min(1.0, bake_opacity)) + """ + config, project_root = minimal_scene_config + screenshot_path = tmp_path / "opacity_clamp.png" + show_scene( + config, + project_root, + irradiance=None, + screenshot=screenshot_path, + bake_opacity=2.5, # 1.0 にクランプされること + ) + assert screenshot_path.exists() + + @pytest.mark.slow + def test_bake_opacity_below_0_is_clamped( + self, + tmp_path: Path, + minimal_scene_config: tuple[SceneConfig, Path], + ): + """bake_opacity < 0.0 を渡しても例外なく正常終了すること（0.0 にクランプ）． + + 仕様: bake_opacity = max(0.0, min(1.0, bake_opacity)) + """ + config, project_root = minimal_scene_config + screenshot_path = tmp_path / "opacity_below0.png" + show_scene( + config, + project_root, + irradiance=None, + screenshot=screenshot_path, + bake_opacity=-0.5, # 0.0 にクランプされること + ) + assert screenshot_path.exists() + + +# --------------------------------------------------------------------------- +# 7. bake_smooth クランプ — 負値が 0 にクランプされること（純ロジック） +# --------------------------------------------------------------------------- + + +class TestBakeSmoothClamp: + """show_scene の bake_smooth クランプ仕様を検証する． + + 仕様（viewer.py show_scene）: + bake_smooth = max(0, bake_smooth) + 負値は 0 にクランプする + """ + + @pytest.mark.slow + def test_bake_smooth_negative_is_clamped_to_0( + self, + tmp_path: Path, + minimal_scene_config: tuple[SceneConfig, Path], + ): + """bake_smooth < 0 を渡しても例外なく正常終了すること（0 にクランプ）． + + 仕様: bake_smooth = max(0, bake_smooth) + """ + config, project_root = minimal_scene_config + screenshot_path = tmp_path / "smooth_neg.png" + show_scene( + config, + project_root, + irradiance=None, + screenshot=screenshot_path, + bake_smooth=-3, # 0 にクランプされること + ) + assert screenshot_path.exists() + + +# --------------------------------------------------------------------------- +# 8. bake_scale 不正値フォールバック（"log" にフォールバック） +# --------------------------------------------------------------------------- + + +class TestBakeScaleFallback: + """show_scene の bake_scale 不正値フォールバック仕様を検証する． + + 仕様（viewer.py show_scene）: + if bake_scale not in ("linear", "log"): + bake_scale = "log" + 未知の bake_scale は "log" にフォールバックする + """ + + @pytest.mark.slow + def test_unknown_bake_scale_falls_back_to_log( + self, + tmp_path: Path, + minimal_scene_config: tuple[SceneConfig, Path], + ): + """bake_scale に不正値を渡しても例外なく正常終了すること（"log" フォールバック）． + + 仕様: bake_scale not in ("linear", "log") → "log" にフォールバック + """ + config, project_root = minimal_scene_config + screenshot_path = tmp_path / "scale_fallback.png" + show_scene( + config, + project_root, + irradiance=None, + screenshot=screenshot_path, + bake_scale="gamma", # 不正値 → "log" フォールバック + ) + assert screenshot_path.exists() + + +# --------------------------------------------------------------------------- +# 9. E = π·L/ρ 換算ロジック（viewer._get_eval_board_reflectance） +# --------------------------------------------------------------------------- + + +class TestEvalBoardIrradianceConversion: + """評価板の照度換算 E = π * L / ρ の仕様を検証する（純関数テスト）． + + 仕様（SPEC_03「筐体（材料）」）: + Lambertian 拡散面: L = ρ * E / π → E = π * L / ρ + ρ: 評価板材料の拡散反射率（既定 0.85、SPEC_03 printer_white） + + viewer._get_eval_board_reflectance が: + - 正常時: 評価板 material の reflectance をスカラ値で返す + - material が DiffuseMaterial でない時: 0.85 フォールバック + - reflectance が範囲外（<=0 or >1）: 0.85 フォールバック + """ + + def _make_config_with_eval_board_material( + self, reflectance + ) -> tuple[SceneConfig, str]: + """評価板メッシュを含む SceneConfig と eval_board_id を返す．""" + from sm_tias_lightsim.scene.schema import SceneConfig + + data = { + "name": "test_e_board", + "geometry": {"meshes": [ + {"id": "evaluation_board", "path": "board.stl", "unit": "mm", "material": "printer_white"}, + {"id": "housing", "path": "housing.stl", "unit": "mm", "material": "printer_white"}, + ]}, + "materials": { + "printer_white": {"type": "diffuse", "reflectance": reflectance}, + }, + "lights": [{"id": "led", "type": "point", "position": [0.0, 0.0, 100.0], + "intensity": 1.0, "profile": "lambertian"}], + "sensor": { + "type": "orthographic", + "position": [0.0, 0.0, -50.0], + "target": [0.0, 0.0, 0.0], + "up": [0.0, 1.0, 0.0], + "ortho_scale": [50.0, 52.0], + "film": {"width": 64, "height": 64}, + }, + "render": {"variant": "scalar_rgb", "integrator": "path", "max_depth": 2, "spp": 1}, + } + return SceneConfig.model_validate(data), "evaluation_board" + + def test_get_eval_board_reflectance_scalar(self): + """scalar reflectance が正しくスカラ値で返ること． + + 仕様（viewer._get_eval_board_reflectance）: + DiffuseMaterial の reflectance がスカラのとき float で返す + """ + from sm_tias_lightsim.visualize.viewer import _get_eval_board_reflectance + + config, eval_id = self._make_config_with_eval_board_material(0.85) + rho = _get_eval_board_reflectance(config, eval_id) + assert rho == pytest.approx(0.85, abs=1e-6) + + def test_get_eval_board_reflectance_baseline_spec(self): + """SPEC_03 基準値 ρ=0.85 が正しく取得されること．""" + from sm_tias_lightsim.visualize.viewer import _get_eval_board_reflectance + + config, eval_id = self._make_config_with_eval_board_material(0.85) + rho = _get_eval_board_reflectance(config, eval_id) + assert rho == pytest.approx(0.85, abs=1e-6), "SPEC_03 基準設計値 ρ=0.85" + + def test_get_eval_board_reflectance_fallback_for_missing_mesh(self): + """評価板メッシュが存在しない場合に ρ=0.85 にフォールバックすること． + + 仕様: 評価板メッシュが見つからない場合は 0.85 をフォールバック値とする + """ + from sm_tias_lightsim.visualize.viewer import _get_eval_board_reflectance + + config, _ = self._make_config_with_eval_board_material(0.90) + # 存在しない id を渡す + rho = _get_eval_board_reflectance(config, "nonexistent_board") + assert rho == pytest.approx(0.85, abs=1e-6), "存在しないメッシュでは 0.85 フォールバック" + + def test_e_board_conversion_formula(self): + """E = π * L / ρ の換算式が正しいこと（数値検証）． + + 仕様（SPEC_03）: Lambertian 拡散面 E = π * L / ρ + L=1.0, ρ=0.85 のとき E = π / 0.85 ≈ 3.6934 + """ + L = np.ones((10, 10), dtype=np.float64) + rho = 0.85 + E_board = np.pi * L / rho + expected = np.pi / 0.85 + + np.testing.assert_allclose( + E_board, expected, + rtol=1e-9, + err_msg="E = π * L / ρ の換算式が正しいこと" + ) + + def test_e_board_larger_than_luminance_for_rho_less_than_pi(self): + """ρ < π のとき E > L であること（Lambertian の物理的性質）． + + 仕様: ρ=0.85 < π なので E = π * L / ρ > L（照度は輝度より大きい） + """ + L = np.full((5, 5), 100.0) + rho = 0.85 + E_board = np.pi * L / rho + assert np.all(E_board > L), "E = π*L/ρ は ρ < π のとき E > L" + + def test_get_eval_board_reflectance_rgb_tuple_uses_rec709(self): + """RGB タプルの reflectance が Rec.709 輝度でスカラ化されること． + + 仕様（viewer._get_eval_board_reflectance）: + RGB タプル → Rec.709 輝度でスカラ化: Y = 0.2126R + 0.7152G + 0.0722B + """ + from sm_tias_lightsim.visualize.viewer import _get_eval_board_reflectance + from sm_tias_lightsim.scene.schema import SceneConfig + + r, g, b = 0.85, 0.85, 0.85 + expected_luma = 0.2126 * r + 0.7152 * g + 0.0722 * b + + data = { + "name": "test_rgb_rho", + "geometry": {"meshes": [ + {"id": "evaluation_board", "path": "board.stl", "unit": "mm", "material": "rgb_white"}, + ]}, + "materials": { + "rgb_white": {"type": "diffuse", "reflectance": [r, g, b]}, + }, + "lights": [{"id": "led", "type": "point", "position": [0.0, 0.0, 100.0], + "intensity": 1.0, "profile": "lambertian"}], + "sensor": { + "type": "orthographic", + "position": [0.0, 0.0, -50.0], + "target": [0.0, 0.0, 0.0], + "up": [0.0, 1.0, 0.0], + "ortho_scale": [50.0, 52.0], + "film": {"width": 64, "height": 64}, + }, + "render": {"variant": "scalar_rgb", "integrator": "path", "max_depth": 2, "spp": 1}, + } + config = SceneConfig.model_validate(data) + rho = _get_eval_board_reflectance(config, "evaluation_board") + assert rho == pytest.approx(expected_luma, abs=1e-6), ( + f"RGB (r,g,b)=({r},{g},{b}) の Rec.709 輝度 {expected_luma:.6f} と一致すること" + )