diff --git a/CLAUDE.md b/CLAUDE.md index 431845d..f582375 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -4,7 +4,7 @@ ## 開発進捗 -最新: ステップ 2（MiniTIAS 照明均一性評価）完了．次はステップ 3 +最新: TECH_05 Phase 1（DNG 読み込み I/F）と動径 min/max 比指標を実装．次は DNG の既存パイプライン統合（TECH_05 Phase 4〜） ※ 本欄は**最新ステップ 1 行のみ上書き更新**．詳細な進捗履歴（動機・設計判断・失敗パターン）は [docs/PROGRESS.md](docs/PROGRESS.md) に追記する．運用ルールは GUIDE_05「進捗記録の運用ルール（CLAUDE.md / PROGRESS.md）」を参照． ## 必須ルール（コード実装時） diff --git "a/docs/02_ENV/ENV_01_\346\212\200\350\241\223\343\202\271\343\202\277\343\203\203\343\202\257.md" "b/docs/02_ENV/ENV_01_\346\212\200\350\241\223\343\202\271\343\202\277\343\203\203\343\202\257.md" index 1fe9fe5..ebeb2b5 100644 --- "a/docs/02_ENV/ENV_01_\346\212\200\350\241\223\343\202\271\343\202\277\343\203\203\343\202\257.md" +++ "b/docs/02_ENV/ENV_01_\346\212\200\350\241\223\343\202\271\343\202\277\343\203\203\343\202\257.md" @@ -10,6 +10,7 @@ | --- | --- | --- | | NumPy | 数値計算・配列操作 | 画像データの行列演算の基盤 | | OpenCV (`opencv-python`) | 画像の読み込み・前処理 | PNG 読み込み，ROI 抽出，色空間変換に対応 | +| rawpy (`rawpy>=0.21.0`) | DNG (RAW_SENSOR) 読み込み | MiniTIAS 定量モードの 10bit Bayer DNG をデモザイク・linear 展開（libraw ベース） | | colour-science | CIE L\*a\*b\* 変換，ΔE 計算 | CIE 規格準拠の色彩計算を正確に実装済み | | Matplotlib | グラフ・図の生成 | 論文掲載用の高品質な図を出力可能 | | pandas | 数値結果の集計・CSV 出力 | 比較表の作成・データ管理に便利 | diff --git a/docs/PROGRESS.md b/docs/PROGRESS.md index fb9f89d..8c81cb2 100644 --- a/docs/PROGRESS.md +++ b/docs/PROGRESS.md @@ -12,3 +12,11 @@ - [x] **ステップ 2: MiniTIAS 照明均一性評価 完了**: 照明均一性の評価指標算出・可視化を実装し，REPORT_01（照明均一性評価報告書）を作成済み．次はステップ 3． - 注: 本エントリはテンプレート同期で PROGRESS.md を新設した際の移記ベースライン（詳細経緯は `git log` を参照）．以降の進捗は本ファイル末尾に追記する． + +- [x] **TECH_05 Phase 1: DNG 読み込み I/F ＋ 動径 min/max 比指標**: MiniTias 定量モードの出力が PNG→DNG(RAW_SENSOR) に変わったため DNG 読み込み I/F（`src/io/dng_loader.py`）を新設．あわせて照明均一性に動径 min/max 比指標を追加．SmTIAS-LightSim へのコピー前提で再利用性重視． + - **設計判断（線形性）**: linear 系出力は `output_color=raw`（カラーマトリクス非適用）とし，入射光量とセンサ信号の比例（放射輝度リニアリティ）を担保．カラーマトリクス経路はチャンネル混合で per-channel 比例が崩れるため不採用．luma は既存 PNG 経路互換のため Rec.709 維持（raw 経路では厳密な CIE 輝度でなく固定加重プロキシ）． + - **重要な発見（仕様との食い違い）**: RAW_SENSOR DNG はレンズシェーディング**未補正**（補正は DNG の OpcodeList2 GainMap・meta.json lscMap として付随するが rawpy は適用しない／lscMap ゲインは 1〜5）．TECH_05 の `apply_lsc_inverse` は「DNG=補正済み」前提だが実際は未補正．照明ムラを測るには lscMap を**順方向適用**してレンズビネットを除去する向きで Phase 3 を設計すること．LSC 順適用で白板 ROI の CoV は約半減を実測． + - **向き**: DNG はセンサ native が landscape，PNG/preview は portrait．PNG と揃えるには `rot90(-1)`（左右反転なし）．フロントカメラ(id=1) の preview はミラーされるが RAW はミラーされないため反転不要（ラベル位置で確認）． + - **PNG vs DNG 比較の注意**: 違いはスケール(0-1/0-255)でなくドメイン（PNG=sRGB / DNG=linear）．CoV 等はスケール不変なので，公平比較には PNG を inverse-sRGB で linear 化する必要がある． + - **動径 min/max 比**: 画素単位 max/min は外れ画素に弱いため，20点輪帯平均の min/max をロバスト指標として追加． + - **後段（未着手）**: TECH_05 Phase 4（既存パイプライン統合）/ Phase 5（PNG vs DNG，撮影フレーミング差への ROI 対応）/ Phase 6（SPEC_01/02 更新）/ ビューア(viewer.py) の DNG 対応．SPEC のフル更新は TECH_05 Phase 6 に委ねる．`scripts/run_uniformity_dng.py` は PNG 版の DNG 対応ランナーとして暫定追加（共通化は将来）． diff --git a/pyproject.toml b/pyproject.toml index fc13c4f..7a1347a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,6 +5,7 @@ requires-python = ">=3.11" dependencies = [ "jinja2", + "rawpy>=0.21.0", ] [tool.pytest.ini_options] diff --git a/requirements.txt b/requirements.txt index 7ef9f0e..8dd4fe5 100644 --- a/requirements.txt +++ b/requirements.txt @@ -7,3 +7,4 @@ streamlit jinja2 scikit-image +rawpy>=0.21.0 diff --git a/scripts/run_uniformity.py b/scripts/run_uniformity.py index 53f4906..b79741a 100644 --- a/scripts/run_uniformity.py +++ b/scripts/run_uniformity.py @@ -129,6 +129,7 @@ print(f" 周辺平均輝度 : {zone_stats['periphery_mean']:.2f}") print(f" 中心/周辺比 : {zone_stats['center_periphery_ratio']:.4f}") print(f" 勾配量 (%) : {zone_stats['gradient_magnitude']:.2f}") + print(f" 動径min/max比 : {spatial['radial_min_max_ratio']:.4f}") # 可視化 luminance_map_path = str(output_base / "figures" / f"{stem}_luminance_map.png") @@ -149,7 +150,11 @@ print(f"解析完了: {image_path}") - return {"image_name": stem, **results, **zone_stats}, luminance + radial_ratio = { + "radial_min_max_ratio": spatial["radial_min_max_ratio"], + "radial_min_distance": spatial["radial_min_distance"], + } + return {"image_name": stem, **results, **zone_stats, **radial_ratio}, luminance def main() -> None: diff --git a/scripts/run_uniformity_dng.py b/scripts/run_uniformity_dng.py new file mode 100644 index 0000000..88d74ed --- /dev/null +++ b/scripts/run_uniformity_dng.py @@ -0,0 +1,258 @@ +"""MiniTIAS 定量モード DNG の照明均一性評価スクリプト（PNG 版 run_uniformity.py の DNG 対応版）. + +PNG 版と同じ出力一式（輝度マップ / ヒストグラム / 動径プロファイル / ゾーンマップ / +均一性 CSV / コンソール指標）を，DNG に対して同じ ROI・同じ向き（portrait）で出力する． + +PNG 版との違い: +- 読み込みを load_image_dng（linear, output_color=raw）に置換 +- DNG は RAW_SENSOR で未補正のため，meta.json の lscMap でレンズシェーディングを順適用（--no-lsc で無効化可） +- DNG はセンサ native が landscape のため，PNG と同じ portrait へ rot90(-1) で向き合わせ + +使い方: + python scripts/run_uniformity_dng.py --image data/minitias/quantitative/xxx.dng +""" + +import argparse +import json +import sys +from pathlib import Path + +import numpy as np + +PROJECT_ROOT = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(PROJECT_ROOT)) + +from src.analysis.spatial import calc_spatial_uniformity # noqa: E402 +from src.analysis.uniformity import ( # noqa: E402 + REC709_COEFF_B, + REC709_COEFF_G, + REC709_COEFF_R, + calc_uniformity, +) +from src.export.exporter import ensure_output_dirs, export_results # noqa: E402 +from src.io.dng_loader import load_image_dng # noqa: E402 +from src.io.loader import extract_roi # noqa: E402 +from src.visualization.plotter import ( # noqa: E402 + plot_histogram, + plot_luminance_map, + plot_radial_profile, + plot_zone_map, +) + + +def load_roi_config(config_path: str, roi_key: str) -> dict | None: + """ROI 設定ファイルを読み込んで指定キーの ROI を返す． + + Args: + config_path: JSON 設定ファイルのパス． + roi_key: ドット区切りのキー（例: "minitias.whiteboard"）． + + Returns: + ROI の辞書（x, y, width, height）．キーが存在しない場合は None． + + Raises: + FileNotFoundError: 設定ファイルが存在しない場合． + """ + config_file = Path(config_path) + if not config_file.exists(): + raise FileNotFoundError(f"設定ファイルが見つかりません: {config_path}") + + with config_file.open(encoding="utf-8") as f: + config = json.load(f) + + # ドット区切りでネストされたキーを辿る + node = config + for key in roi_key.split("."): + if not isinstance(node, dict) or key not in node: + return None + node = node[key] + + return node if isinstance(node, dict) else None + + +def _upsample(grid: np.ndarray, shape: tuple[int, int]) -> np.ndarray: + """(rows, cols) グリッドを画像サイズ shape へバイリニア補間する． + + Args: + grid: 補間元グリッドの NumPy 配列（rows x cols, float64）． + shape: 補間先の画像サイズ (height, width)． + + Returns: + 補間後の NumPy 配列（height x width, float64）． + """ + rows, cols = grid.shape + h, w = shape + ys = np.linspace(0, rows - 1, h) + xs = np.linspace(0, cols - 1, w) + y0 = np.floor(ys).astype(int) + y1 = np.minimum(y0 + 1, rows - 1) + x0 = np.floor(xs).astype(int) + x1 = np.minimum(x0 + 1, cols - 1) + wy = (ys - y0)[:, None] + wx = (xs - x0)[None, :] + top = grid[y0][:, x0] * (1 - wx) + grid[y0][:, x1] * wx + bot = grid[y1][:, x0] * (1 - wx) + grid[y1][:, x1] * wx + return top * (1 - wy) + bot * wy + + +def lsc_gain_rgb(meta_path: Path, shape: tuple[int, int]) -> np.ndarray: + """meta.json の lscMap (4, M, N) を (H, W, 3) の RGB ゲインへ補間する． + + 4ch = [R, G_even, G_odd, B]．G は G_even/G_odd の平均を用いる． + + Args: + meta_path: meta.json ファイルのパス． + shape: 補間先の画像サイズ (height, width)． + + Returns: + RGB ゲインの NumPy 配列（H x W x 3, float64）． + """ + meta = json.loads(meta_path.read_text(encoding="utf-8")) + rows, cols = meta["lscMapRowCount"], meta["lscMapColumnCount"] + m = np.array(meta["lscMap"], dtype=np.float64).reshape(rows, cols, 4) + gr = _upsample(m[:, :, 0], shape) + gg = _upsample((m[:, :, 1] + m[:, :, 2]) / 2.0, shape) + gb = _upsample(m[:, :, 3], shape) + return np.stack([gr, gg, gb], axis=2) + + +def dng_luminance(image_path: str, apply_lsc: bool) -> np.ndarray: + """DNG から portrait・linear・（任意で LSC 補正済）の輝度画像を返す． + + - output_format="rgb_float32"（output_color=raw, linear）で読み込み + - apply_lsc=True なら lscMap を順適用してレンズビネットを除去 + - Rec.709 で輝度化（uniformity.py と同じ係数） + - PNG と同じ portrait へ rot90(-1) で向き合わせ + + Args: + image_path: DNG ファイルのパス． + apply_lsc: True の場合，同名 .meta.json から LSC ゲインを読み込んで補正する． + + Returns: + portrait 向きの輝度画像（H x W, float64）．値域は 0〜255 の linear スケール． + """ + rgb = load_image_dng(image_path, output_format="rgb_float32") # (H,W,3) linear landscape + + if apply_lsc: + meta_path = Path(image_path).with_suffix("").with_suffix(".meta.json") + if not meta_path.exists(): + # ".meta.json" は二重拡張子なので with_suffix では拾えない場合がある + meta_path = Path(str(Path(image_path).with_suffix("")) + ".meta.json") + if not meta_path.exists(): + raise FileNotFoundError(f"meta.json が見つかりません（LSC 補正に必要）: {meta_path}") + rgb = rgb * lsc_gain_rgb(meta_path, rgb.shape[:2]) + + luma = ( + REC709_COEFF_R * rgb[:, :, 0] + + REC709_COEFF_G * rgb[:, :, 1] + + REC709_COEFF_B * rgb[:, :, 2] + ) + # linear のまま 0〜255 スケールで表現する（PNG 図と軸を揃えて比較するため）． + # CoV・max/min・中心周辺比はスケール不変なので不変，mean/std のみ ×255 となる． + # 既存 plot_histogram が range=(0,255) 固定であることにも整合する． + luma = luma * 255.0 + return np.rot90(luma, -1) # portrait（PNG と同じ向き） + + +def analyze_single_dng( + image_path: str, + roi: dict | None, + output_base: Path, + apply_lsc: bool, +) -> None: + """DNG 1 枚を解析し，PNG 版と同じ出力一式を生成する． + + Args: + image_path: 解析対象 DNG ファイルのパス． + roi: ROI の辞書（x, y, width, height）．None の場合は画像全体を解析． + output_base: 出力ルートディレクトリのパス． + apply_lsc: True の場合，LSC（レンズシェーディング）補正を適用する． + """ + print(f"解析開始: {image_path}") + luma_full = dng_luminance(image_path, apply_lsc) + print(f"画像サイズ: {luma_full.shape[1]} x {luma_full.shape[0]} px（portrait）") + print(f"LSC 補正: {'あり' if apply_lsc else 'なし'} / ドメイン: linear（output_color=raw）") + + if roi is not None: + print( + f"ROI を適用します: x={roi['x']}, y={roi['y']}, " + f"width={roi['width']}, height={roi['height']}" + ) + luminance = extract_roi(luma_full, roi["x"], roi["y"], roi["width"], roi["height"]) + else: + print("ROI 未指定: 画像全体を解析します") + luminance = luma_full + + results = calc_uniformity(luminance) + print("--- 均一性指標（輝度は 0〜255 linear スケール）---") + print(f" 平均輝度 : {results['mean']:.2f}") + print(f" 標準偏差 : {results['std']:.2f}") + print(f" CoV : {results['cov']:.4f}") + print(f" 最大/最小比 : {results['max_min_ratio']:.4f}") + print(f" 最大輝度 : {results['max']:.2f}") + print(f" 最小輝度 : {results['min']:.2f}") + + spatial = calc_spatial_uniformity(luminance) + zone_stats = spatial["zone_stats"] + print("--- 空間解析指標 ---") + print(f" 中心平均輝度 : {zone_stats['center_mean']:.2f}") + print(f" 中間平均輝度 : {zone_stats['middle_mean']:.2f}") + print(f" 周辺平均輝度 : {zone_stats['periphery_mean']:.2f}") + print(f" 中心/周辺比 : {zone_stats['center_periphery_ratio']:.4f}") + print(f" 勾配量 (%) : {zone_stats['gradient_magnitude']:.2f}") + print(f" 動径min/max比 : {spatial['radial_min_max_ratio']:.4f}") + + stem = Path(image_path).stem # 例: MiniTIAS_QM_20260601_102753 + figures = output_base / "figures" + plot_luminance_map(luminance, str(figures / f"{stem}_luminance_map.png")) + plot_histogram(luminance, str(figures / f"{stem}_histogram.png")) + plot_radial_profile(spatial["radial_profile"], str(figures / f"{stem}_radial_profile.png")) + plot_zone_map(luminance, spatial["zone_map"], str(figures / f"{stem}_zone_map.png")) + export_results(results, str(output_base / "results" / f"{stem}_uniformity.csv")) + + print(f"解析完了: {image_path}") + + +def main() -> None: + """エントリーポイント.""" + parser = argparse.ArgumentParser( + description="MiniTIAS 定量モード DNG の照明均一性を評価する（PNG 版と同じ出力一式）." + ) + parser.add_argument("--image", required=True, help="解析対象の DNG ファイルパス") + parser.add_argument( + "--config", + default=str(PROJECT_ROOT / "config" / "roi_config.json"), + help="ROI 設定ファイルのパス（デフォルト: config/roi_config.json）", + ) + parser.add_argument( + "--roi", + default="minitias.whiteboard", + help="ROI のキー（ドット区切り，デフォルト: minitias.whiteboard）", + ) + parser.add_argument( + "--output", + default=str(PROJECT_ROOT / "output"), + help="出力ディレクトリのパス（デフォルト: output/）", + ) + parser.add_argument( + "--no-lsc", + action="store_true", + help="LSC（レンズシェーディング）補正を無効化する（既定は補正あり）", + ) + args = parser.parse_args() + + output_base = Path(args.output) + ensure_output_dirs(args.output) + + roi = None + if args.config: + try: + roi = load_roi_config(args.config, args.roi) + except FileNotFoundError as e: + print(f"警告: {e} → 画像全体を解析します") + + analyze_single_dng(args.image, roi, output_base, apply_lsc=not args.no_lsc) + + +if __name__ == "__main__": + main() diff --git a/src/analysis/spatial.py b/src/analysis/spatial.py index 184e276..5282fa8 100644 --- a/src/analysis/spatial.py +++ b/src/analysis/spatial.py @@ -150,6 +150,48 @@ return profile +def calc_radial_min_max_ratio(radial_profile: numpy.ndarray) -> dict: + """動径プロファイルの最小/最大輝度比を算出する． + + 20 点の輪帯平均輝度のうち最小値を最大値で割った比（0〜1）を返す． + 1 に近いほど均一で，中心明・周辺暗の単調減衰では「最外輪帯 / 最内輪帯」に一致する． + 全 20 点の min/max を使うため，非単調プロファイルにもロバストに対応する． + + Args: + radial_profile: 放射状プロファイルの NumPy 配列（N x 2, float64）． + 列 0 = ビン中心距離, 列 1 = 平均輝度． + + Returns: + 動径 min/max 比を格納した辞書．キーは: + "radial_min_max_ratio" (float): 最小輝度 / 最大輝度（0〜1）． + 最大輝度が 0 の場合は float("inf")． + "radial_min_distance" (float): 最小輝度ビンの正規化距離． + "radial_min" (float): プロファイルの最小輝度値． + "radial_max" (float): プロファイルの最大輝度値． + """ + luminances = radial_profile[:, 1] + distances = radial_profile[:, 0] + + radial_min = float(numpy.min(luminances)) + radial_max = float(numpy.max(luminances)) + + # max が 0 のときはゼロ除算を回避して inf を返す（calc_zone_stats の既存パターンに倣う） + radial_min_max_ratio = ( + radial_min / radial_max if radial_max != 0.0 else float("inf") + ) + + # 最小輝度をとるビンの正規化距離（補助情報） + min_idx = int(numpy.argmin(luminances)) + radial_min_distance = float(distances[min_idx]) + + return { + "radial_min_max_ratio": radial_min_max_ratio, + "radial_min_distance": radial_min_distance, + "radial_min": radial_min, + "radial_max": radial_max, + } + + def calc_spatial_uniformity(luminance: numpy.ndarray) -> dict: """空間的均一性指標を一括算出するファサード関数． @@ -162,16 +204,20 @@ Returns: 空間分析結果を格納した辞書．キーは: "zone_stats" (dict), "radial_profile" (numpy.ndarray), - "zone_map" (numpy.ndarray)． + "zone_map" (numpy.ndarray), + "radial_min_max_ratio" (float), "radial_min_distance" (float), + "radial_min" (float), "radial_max" (float)． """ height, width = luminance.shape distance_map = calc_distance_map(height, width) zone_map = classify_zones(distance_map) zone_stats = calc_zone_stats(luminance, zone_map) radial_profile = calc_radial_profile(luminance, distance_map) + radial_ratio_stats = calc_radial_min_max_ratio(radial_profile) return { "zone_stats": zone_stats, "radial_profile": radial_profile, "zone_map": zone_map, + **radial_ratio_stats, } diff --git a/src/export/exporter.py b/src/export/exporter.py index 1931aa4..a3521ec 100644 --- a/src/export/exporter.py +++ b/src/export/exporter.py @@ -13,6 +13,8 @@ "periphery_mean", "center_periphery_ratio", "gradient_magnitude", + "radial_min_max_ratio", + "radial_min_distance", ] @@ -119,6 +121,8 @@ "periphery_mean", "center_periphery_ratio", "gradient_magnitude", + "radial_min_max_ratio", + "radial_min_distance", ] def _calc_metric_stats(metric_name: str) -> dict: diff --git a/src/io/dng_loader.py b/src/io/dng_loader.py new file mode 100644 index 0000000..70c77eb --- /dev/null +++ b/src/io/dng_loader.py @@ -0,0 +1,193 @@ +"""MiniTIAS 定量モード DNG 読み込みモジュール.""" + +from pathlib import Path + +import numpy +import rawpy + + +# Rec.709 グレースケール変換係数（uniformity.py の REC709_COEFF_* と一致させる） +# 参照: ITU-R BT.709 (https://www.itu.int/rec/R-REC-BT.709/en) +_REC709_R = 0.2126 +_REC709_G = 0.7152 +_REC709_B = 0.0722 + +# demosaic 引数 → rawpy.DemosaicAlgorithm のマッピング +# 参照: https://letmaik.github.io/rawpy/api/rawpy.DemosaicAlgorithm.html +_DEMOSAIC_MAP: dict[str, rawpy.DemosaicAlgorithm] = { + "nearest": rawpy.DemosaicAlgorithm.LINEAR, # 最近傍は rawpy に専用 enum がないため LINEAR で代替 + "bilinear": rawpy.DemosaicAlgorithm.LINEAR, + "ahd": rawpy.DemosaicAlgorithm.AHD, +} + +# 有効な output_format の一覧 +_VALID_OUTPUT_FORMATS = {"rgb_float32", "luma_float32", "rgb_uint8"} + +# rawpy が output_bps=16 で返す uint16 の最大値（0〜65535 を [0, 1] に正規化するため） +_UINT16_MAX = 65535.0 + + +def load_image_dng( + path: str, + demosaic: str = "bilinear", + black_level: int | None = None, + output_format: str = "rgb_float32", +) -> numpy.ndarray: + """MiniTIAS 定量モード DNG を読み込み配列として返す． + + rawpy の postprocess() を linear パラメータで呼び出すことで， + ISP（ガンマ・自動輝度・カメラ WB）の介入を最小化した linear raw 値を取り出す． + 具体的には gamma=(1,1), no_auto_bright=True, output_bps=16, use_camera_wb=False を指定する． + + Args: + path: DNG ファイルのパス． + demosaic: デモザイクアルゴリズム．既定 "bilinear"． + "nearest"（最近傍）/ "bilinear"（双線形）/ "ahd"（適応的）から選択． + "nearest" は rawpy に専用実装がないため "bilinear" と同一の LINEAR を使用する． + bilinear（既定）は線形演算で比例性を保つ． + **AHD は適応的＝非線形でチャンネル間の比例が崩れうるため量的評価では非推奨**． + black_level: 黒レベル（整数）．None なら DNG Exif の + black_level_per_channel[0] から自動取得する．通常は 64（SH-02M）． + output_format: 出力形式．既定 "rgb_float32"． + "rgb_float32": (H, W, 3) float32, linear, 値域 [0.0, 1.0]． + output_color=raw（カラーマトリクス非適用）でカメラ固有チャンネルの + linear raw 信号を出力する．各チャンネルがそのセンサチャンネルの + 入射光量に比例する（チャンネル混合なし）． + 飽和画素は 1.0 を超えることがある（クリップしない）． + "luma_float32": (H, W) float32, linear, 値域 [0.0, 1.0]． + output_color=raw（カラーマトリクス非適用）でカメラ固有チャンネルの + linear raw 信号を取得し，Rec.709 重みで輝度に変換する + （uniformity.py の to_grayscale と同じ係数）． + **output_color=raw のとき Rec.709 luma は厳密な CIE 輝度ではなく， + 既存 PNG 経路（uniformity.py の to_grayscale）と互換の固定加重輝度プロキシ + である**．Rec.709 係数を維持する理由は，既存パイプラインとの方法論的一貫性 + と DNG/PNG 評価指標の直接比較のためである． + "rgb_uint8": (H, W, 3) uint8, カラーマトリクス＋sRGB OETF 適用後． + output_color=sRGB（カラーマトリクス適用）＋ sRGB OETF を維持する． + 表示・PNG 互換専用であり，量的評価には linear 形式（rgb_float32 / + luma_float32）を使うこと． + + Returns: + numpy.ndarray. 形状・dtype は output_format に依存． + + Raises: + FileNotFoundError: ファイルが存在しない場合． + ValueError: demosaic または output_format の値が不正な場合， + または rawpy が DNG を読み込めなかった場合（形式が不正等）． + """ + if not Path(path).exists(): + raise FileNotFoundError(f"DNG ファイルが見つかりません: {path}") + + if demosaic not in _DEMOSAIC_MAP: + raise ValueError( + f"demosaic の値が不正です: '{demosaic}'．" + f"有効な値: {sorted(_DEMOSAIC_MAP.keys())}" + ) + + if output_format not in _VALID_OUTPUT_FORMATS: + raise ValueError( + f"output_format の値が不正です: '{output_format}'．" + f"有効な値: {sorted(_VALID_OUTPUT_FORMATS)}" + ) + + try: + raw = rawpy.imread(str(path)) + except Exception as exc: + raise ValueError( + f"DNG の読み込みに失敗しました（形式が不正の可能性があります）: {path}" + ) from exc + + # rawpy.postprocess() は DNG Exif の black_level_per_channel / white_level を + # 内部で自動取得して黒レベル除去・正規化を行う． + # postprocess に black_level を直接渡す API はないため，引数値の検証は行わない． + # （将来の自前デモザイク実装時に black_level 引数を活用できるよう API として保持している） + # SH-02M: black_level_per_channel=[64,64,64,64], white_level=1023 (scale=959) + + # 共通パラメータ: linear 出力のための ISP 無効化設定 + # - gamma=(1,1): ガンマ補正なし（linear のまま出力） + # - no_auto_bright=True: 自動輝度調整を無効化 + # - output_bps=16: 16-bit 出力（精度確保のため） + # - use_camera_wb=False + user_wb=[1,1,1,1]: WB ゲインをすべて 1 に固定（無補正） + # - demosaic_algorithm: ユーザー指定アルゴリズム + # rawpy.postprocess は DNG Exif から黒レベルと white_level を読み取り， + # (raw - black_level) / (white_level - black_level) を 0〜65535 にスケールして出力する． + # gamma=(1,1) により出力は linear のまま保たれる． + # SH-02M の定量モード DNG は TONEMAP_MODE=CONTRAST_CURVE_LINEAR であり， + # sRGB OETF は適用されていないため，このパラメータで正しく linear raw が得られる． + _postprocess_common = { + "demosaic_algorithm": _DEMOSAIC_MAP[demosaic], + "gamma": (1, 1), + "no_auto_bright": True, + "output_bps": 16, + "use_camera_wb": False, + "user_wb": [1.0, 1.0, 1.0, 1.0], + } + + if output_format in ("rgb_float32", "luma_float32"): + # output_color=raw: カラーマトリクスを通さずカメラ固有チャンネルの linear raw 信号を出力． + # これにより各チャンネルがそのセンサチャンネルの入射光量に比例する（チャンネル混合なし）． + # SmTIAS-LightSim がチャンネル単位でシミュ vs 実機を突合するため per-channel の + # センサ忠実度を優先する．output_color=sRGB（既定）はカラーマトリクスを適用するため + # 各出力チャンネルが他チャンネルの線形結合となり，量的評価に不適切である． + rgb16 = raw.postprocess( + **_postprocess_common, + output_color=rawpy.ColorSpace.raw, + ) + # rgb16: (H, W, 3) uint16，値域 0〜65535（black_level 補正済み linear，white_level で正規化） + rgb_float = rgb16.astype(numpy.float32) / _UINT16_MAX + # rgb_float: (H, W, 3) float32, linear, 値域 [0, 1] + + raw.close() + + if output_format == "rgb_float32": + return rgb_float + + # output_format == "luma_float32" + # Rec.709 重みで輝度に変換（uniformity.py の to_grayscale と同じ係数）． + # output_color=raw のとき Rec.709 luma は厳密な CIE 輝度ではなく固定加重輝度プロキシ． + # 既存 PNG 経路（uniformity.py の to_grayscale）との方法論的一貫性と + # DNG/PNG 評価指標の直接比較のために Rec.709 係数を維持する． + luma = ( + _REC709_R * rgb_float[:, :, 0] + + _REC709_G * rgb_float[:, :, 1] + + _REC709_B * rgb_float[:, :, 2] + ) + return luma # (H, W) float32 + + # output_format == "rgb_uint8" + # output_color=sRGB: カラーマトリクス＋sRGB OETF 適用（既存 PNG 経路と互換）． + # 表示・PNG 互換専用であり，量的評価には rgb_float32 / luma_float32 を使うこと． + # sRGB OETF: V <= 0.0031308 → 12.92 * V, else 1.055 * V^(1/2.4) - 0.055 + # 参照: IEC 61966-2-1 (sRGB standard) + rgb16 = raw.postprocess( + **_postprocess_common, + output_color=rawpy.ColorSpace.sRGB, + ) + rgb_float = rgb16.astype(numpy.float32) / 65535.0 + raw.close() + + rgb_srgb = _apply_srgb_oetf(rgb_float) + rgb_uint8 = numpy.clip(rgb_srgb * 255.0, 0, 255).astype(numpy.uint8) + return rgb_uint8 # (H, W, 3) uint8 + + +def _apply_srgb_oetf(linear: numpy.ndarray) -> numpy.ndarray: + """Linear float 画像に sRGB OETF を適用する． + + IEC 61966-2-1 に基づく区分関数: + V <= 0.0031308: out = 12.92 * V + V > 0.0031308: out = 1.055 * V^(1/2.4) - 0.055 + + Args: + linear: (H, W, 3) float32, 値域 [0.0, 1.0]． + + Returns: + sRGB OETF 適用後の (H, W, 3) float32, 値域 [0.0, 1.0]． + """ + # ゼロ以下の値はそのまま（負値クリップはしない） + out = numpy.where( + linear <= 0.0031308, + 12.92 * linear, + 1.055 * numpy.power(numpy.maximum(linear, 0.0), 1.0 / 2.4) - 0.055, + ) + return out.astype(numpy.float32) diff --git a/src/visualization/plotter.py b/src/visualization/plotter.py index c58059c..1136a86 100644 --- a/src/visualization/plotter.py +++ b/src/visualization/plotter.py @@ -1,5 +1,6 @@ """輝度マップ・ヒストグラム・空間分析可視化モジュール.""" +import math from pathlib import Path import matplotlib.pyplot as plt @@ -63,6 +64,9 @@ def plot_radial_profile(radial_profile: numpy.ndarray, output_path: str) -> None: """放射状輝度プロファイルを折れ線グラフとして保存する． + 最小輝度点（赤マーカー）と最大輝度点（緑マーカー）を強調表示し， + 動径 min/max 比をグラフ右上にアノテーションとして表示する． + Args: radial_profile: 放射状プロファイルの NumPy 配列（N x 2, float64）． 列 0 = 正規化距離, 列 1 = 平均輝度． @@ -70,12 +74,44 @@ """ _ensure_parent(output_path) + distances = radial_profile[:, 0] + luminances = radial_profile[:, 1] + + # min/max 点のインデックスを特定する + min_idx = int(numpy.argmin(luminances)) + max_idx = int(numpy.argmax(luminances)) + lmin = float(luminances[min_idx]) + lmax = float(luminances[max_idx]) + ratio = lmin / lmax if lmax != 0.0 else float("inf") + fig, ax = plt.subplots(figsize=(8, 5)) - ax.plot(radial_profile[:, 0], radial_profile[:, 1], marker="o", color="steelblue") + ax.plot(distances, luminances, marker="o", color="steelblue", label="Mean Luminance") + + # 最大点（緑）・最小点（赤）を強調マーカーで重ねる + ax.scatter( + distances[max_idx], lmax, + color="green", s=80, zorder=5, label=f"Max: {lmax:.2f}", + ) + ax.scatter( + distances[min_idx], lmin, + color="red", s=80, zorder=5, label=f"Min: {lmin:.2f}", + ) + + # 動径 min/max 比をグラフ右上にテキスト注記する + ratio_text = "min/max ratio: inf" if math.isinf(ratio) else f"min/max ratio: {ratio:.4f}" + ax.text( + 0.98, 0.97, ratio_text, + transform=ax.transAxes, + ha="right", va="top", + fontsize=10, + bbox={"boxstyle": "round,pad=0.3", "facecolor": "white", "alpha": 0.8}, + ) + ax.set_title("Radial Luminance Profile") ax.set_xlabel("Normalized Distance from Center") ax.set_ylabel("Mean Luminance") ax.grid(True, linestyle="--", alpha=0.5) + ax.legend(loc="lower left") fig.tight_layout() fig.savefig(output_path, dpi=150) plt.close(fig) diff --git a/tests/analysis/test_radial_min_max.py b/tests/analysis/test_radial_min_max.py new file mode 100644 index 0000000..dd27514 --- /dev/null +++ b/tests/analysis/test_radial_min_max.py @@ -0,0 +1,645 @@ +"""calc_radial_min_max_ratio の単体テスト. + +仕様 (実装サマリー / TECH_05_MiniTiasEvaluation_DNG対応要求仕様.md): + - calc_radial_min_max_ratio(radial_profile) -> dict + - 引数: 20 点動径プロファイル配列 (N x 2, float64) + - 返り値キー: + "radial_min_max_ratio" : min(profile[:,1]) / max(profile[:,1]) + "radial_min_distance" : 最小輝度ビンの正規化距離 + "radial_min" : プロファイルの最小輝度値 + "radial_max" : プロファイルの最大輝度値 + - max=0 のゼロ除算は float("inf") でガード + + - calc_spatial_uniformity の戻り値トップレベルに上記 4 キーを追加 + （既存キー zone_stats / radial_profile / zone_map は不変） + + - SPATIAL_FIELDNAMES に radial_min_max_ratio / radial_min_distance を追加 + + - export_spatial_summary が新指標を CSV に書き出せること + +テスト方針 (GUIDE_08_テスト方針.md): + - pytest を使用 + - numpy で合成した既知のプロファイルで期待値と比較する +""" + +import csv +from pathlib import Path + +import numpy +import numpy as np +import pytest + +from src.analysis.spatial import ( + calc_radial_min_max_ratio, + calc_spatial_uniformity, +) +from src.export.exporter import SPATIAL_FIELDNAMES, export_spatial_summary + + +# --------------------------------------------------------------------------- +# calc_radial_min_max_ratio テスト +# --------------------------------------------------------------------------- + + +class TestCalcRadialMinMaxRatio: + """calc_radial_min_max_ratio 関数のテスト群.""" + + def _make_profile(self, luminances: list[float]) -> numpy.ndarray: + """輝度値リストから動径プロファイル配列 (N x 2) を生成するヘルパー.""" + n = len(luminances) + distances = numpy.linspace(0.025, 0.975, n) + lums = numpy.array(luminances, dtype=numpy.float64) + return numpy.column_stack([distances, lums]) + + def test_return_value_has_all_required_keys(self) -> None: + """仕様: 返り値に radial_min_max_ratio / radial_min_distance / radial_min / radial_max + の 4 キーが含まれること.""" + profile = self._make_profile([100.0, 90.0, 80.0, 70.0, 60.0]) + result = calc_radial_min_max_ratio(profile) + + assert "radial_min_max_ratio" in result + assert "radial_min_distance" in result + assert "radial_min" in result + assert "radial_max" in result + + def test_ratio_is_min_divided_by_max(self) -> None: + """仕様: radial_min_max_ratio が min / max と一致すること（手計算値）.""" + # min=60, max=100 → ratio=0.6 + profile = self._make_profile([100.0, 90.0, 80.0, 70.0, 60.0]) + result = calc_radial_min_max_ratio(profile) + + assert result["radial_min"] == pytest.approx(60.0) + assert result["radial_max"] == pytest.approx(100.0) + assert result["radial_min_max_ratio"] == pytest.approx(60.0 / 100.0) + + def test_ratio_exact_computation_known_values(self) -> None: + """仕様: 既知の min/max で ratio が手計算値と一致すること.""" + # min=40, max=200 → ratio=0.2 + profile = self._make_profile([200.0, 150.0, 100.0, 70.0, 40.0]) + result = calc_radial_min_max_ratio(profile) + assert result["radial_min_max_ratio"] == pytest.approx(40.0 / 200.0) + + def test_uniform_profile_ratio_is_1(self) -> None: + """仕様: 均一プロファイル（全ビン同値）では ratio=1.0 であること.""" + profile = self._make_profile([150.0] * 20) + result = calc_radial_min_max_ratio(profile) + assert result["radial_min_max_ratio"] == pytest.approx(1.0) + + def test_ratio_is_between_0_and_1_for_positive_values(self) -> None: + """仕様: 全値が正のプロファイルでは 0 < ratio <= 1 であること.""" + profile = self._make_profile([100.0, 80.0, 60.0, 40.0, 20.0]) + result = calc_radial_min_max_ratio(profile) + assert 0.0 < result["radial_min_max_ratio"] <= 1.0 + + def test_max_is_zero_returns_inf(self) -> None: + """仕様: max=0 のゼロ除算ガード — float("inf") が返ること.""" + profile = self._make_profile([0.0, 0.0, 0.0, 0.0, 0.0]) + result = calc_radial_min_max_ratio(profile) + assert result["radial_min_max_ratio"] == float("inf") + + def test_min_distance_is_distance_of_minimum_luminance_bin(self) -> None: + """仕様: radial_min_distance が最小輝度をとるビンの正規化距離であること.""" + # 最小値が最後のビン（最外）にある場合 + luminances = [100.0, 90.0, 80.0, 70.0, 60.0] # 最後が最小 + profile = self._make_profile(luminances) + result = calc_radial_min_max_ratio(profile) + + # プロファイルの最小値インデックス = 4（最後） + expected_distance = profile[4, 0] + assert result["radial_min_distance"] == pytest.approx(expected_distance) + + def test_min_distance_for_non_monotonic_profile(self) -> None: + """仕様: 非単調プロファイルでも最小輝度ビンの距離を正しく返すこと.""" + # 中間のビンが最小 + luminances = [100.0, 120.0, 40.0, 90.0, 80.0] # index 2 が最小 + profile = self._make_profile(luminances) + result = calc_radial_min_max_ratio(profile) + + expected_distance = profile[2, 0] + assert result["radial_min_distance"] == pytest.approx(expected_distance) + + def test_radial_min_equals_min_of_luminance_column(self) -> None: + """仕様: radial_min がプロファイルの輝度列の最小値であること.""" + luminances = [100.0, 50.0, 80.0, 30.0, 70.0] + profile = self._make_profile(luminances) + result = calc_radial_min_max_ratio(profile) + assert result["radial_min"] == pytest.approx(30.0) + + def test_radial_max_equals_max_of_luminance_column(self) -> None: + """仕様: radial_max がプロファイルの輝度列の最大値であること.""" + luminances = [100.0, 50.0, 80.0, 30.0, 70.0] + profile = self._make_profile(luminances) + result = calc_radial_min_max_ratio(profile) + assert result["radial_max"] == pytest.approx(100.0) + + def test_return_values_are_float_type(self) -> None: + """仕様: 戻り値の各フィールドが Python float 型であること.""" + profile = self._make_profile([100.0, 80.0, 60.0]) + result = calc_radial_min_max_ratio(profile) + for key in result: + assert isinstance(result[key], float), f"{key} が float でない: {type(result[key])}" + + def test_20_point_profile_standard_size(self) -> None: + """仕様: 20 点の動径プロファイル（仕様の標準サイズ）で正常に動作すること.""" + # 単調減衰 20 点プロファイル（仕様の標準サイズ） + luminances = numpy.linspace(200.0, 100.0, 20).tolist() + profile = self._make_profile(luminances) + result = calc_radial_min_max_ratio(profile) + + assert result["radial_min_max_ratio"] == pytest.approx(100.0 / 200.0) + assert result["radial_min"] == pytest.approx(100.0) + assert result["radial_max"] == pytest.approx(200.0) + + def test_monotone_decreasing_ratio_is_less_than_1(self) -> None: + """仕様: 単調減衰プロファイルでは ratio < 1.0 であること.""" + luminances = numpy.linspace(200.0, 100.0, 20).tolist() + profile = self._make_profile(luminances) + result = calc_radial_min_max_ratio(profile) + assert result["radial_min_max_ratio"] < 1.0 + + def test_monotone_decreasing_min_distance_is_at_periphery(self) -> None: + """仕様: 単調減衰プロファイルでは radial_min_distance が最外付近にあること. + + 単調減衰（中心明・周辺暗）の合成画像では最小輝度ビンが最外（距離 1.0 付近）になる． + """ + luminances = numpy.linspace(200.0, 100.0, 20).tolist() + profile = self._make_profile(luminances) + result = calc_radial_min_max_ratio(profile) + + # 最外ビン（距離が最大のビン）に最小値があること + max_distance = profile[-1, 0] + assert result["radial_min_distance"] == pytest.approx(max_distance) + + +# --------------------------------------------------------------------------- +# calc_spatial_uniformity の新 4 キー テスト +# --------------------------------------------------------------------------- + + +class TestCalcSpatialUniformityNewKeys: + """calc_spatial_uniformity が新 4 キーを含む仕様検証テスト群.""" + + @pytest.fixture + def sample_luminance(self) -> numpy.ndarray: + """テスト用の 20x20 均一輝度画像を返す fixture.""" + return numpy.full((20, 20), 128.0, dtype=numpy.float64) + + @pytest.fixture + def decaying_luminance(self) -> numpy.ndarray: + """中心明・周辺暗の合成輝度画像（30x30）を返す fixture. + + 中心座標からの距離に応じて輝度が低下する画像． + """ + h, w = 30, 30 + cy, cx = h / 2, w / 2 + y_coords, x_coords = numpy.mgrid[0:h, 0:w] + dist = numpy.sqrt(((x_coords - cx) / cx) ** 2 + ((y_coords - cy) / cy) ** 2) + dist_norm = dist / dist.max() + # 中心=200, 周辺=100 の線形減衰 + luminance = 200.0 - 100.0 * dist_norm + return luminance.astype(numpy.float64) + + def test_return_value_has_radial_min_max_ratio_key( + self, sample_luminance: numpy.ndarray + ) -> None: + """仕様: calc_spatial_uniformity の戻り値に 'radial_min_max_ratio' キーが存在すること.""" + result = calc_spatial_uniformity(sample_luminance) + assert "radial_min_max_ratio" in result + + def test_return_value_has_radial_min_distance_key( + self, sample_luminance: numpy.ndarray + ) -> None: + """仕様: calc_spatial_uniformity の戻り値に 'radial_min_distance' キーが存在すること.""" + result = calc_spatial_uniformity(sample_luminance) + assert "radial_min_distance" in result + + def test_return_value_has_radial_min_key( + self, sample_luminance: numpy.ndarray + ) -> None: + """仕様: calc_spatial_uniformity の戻り値に 'radial_min' キーが存在すること.""" + result = calc_spatial_uniformity(sample_luminance) + assert "radial_min" in result + + def test_return_value_has_radial_max_key( + self, sample_luminance: numpy.ndarray + ) -> None: + """仕様: calc_spatial_uniformity の戻り値に 'radial_max' キーが存在すること.""" + result = calc_spatial_uniformity(sample_luminance) + assert "radial_max" in result + + def test_existing_keys_are_preserved(self, sample_luminance: numpy.ndarray) -> None: + """仕様: 既存キー zone_stats / radial_profile / zone_map が変わらず保持されること.""" + result = calc_spatial_uniformity(sample_luminance) + assert "zone_stats" in result + assert "radial_profile" in result + assert "zone_map" in result + + def test_radial_min_max_ratio_type_is_float( + self, sample_luminance: numpy.ndarray + ) -> None: + """仕様: radial_min_max_ratio が float 型であること.""" + result = calc_spatial_uniformity(sample_luminance) + assert isinstance(result["radial_min_max_ratio"], float) + + def test_radial_min_distance_type_is_float( + self, sample_luminance: numpy.ndarray + ) -> None: + """仕様: radial_min_distance が float 型であること.""" + result = calc_spatial_uniformity(sample_luminance) + assert isinstance(result["radial_min_distance"], float) + + def test_uniform_image_ratio_is_1(self, sample_luminance: numpy.ndarray) -> None: + """仕様: 均一輝度画像では radial_min_max_ratio が 1.0 であること.""" + result = calc_spatial_uniformity(sample_luminance) + assert result["radial_min_max_ratio"] == pytest.approx(1.0, abs=1e-5) + + def test_decaying_image_ratio_is_between_0_and_1( + self, decaying_luminance: numpy.ndarray + ) -> None: + """仕様: 単調減衰画像では 0 < radial_min_max_ratio < 1 であること.""" + result = calc_spatial_uniformity(decaying_luminance) + ratio = result["radial_min_max_ratio"] + assert 0.0 < ratio < 1.0 + + def test_decaying_image_min_distance_is_at_periphery( + self, decaying_luminance: numpy.ndarray + ) -> None: + """仕様: 単調減衰画像では radial_min_distance が最外付近（> 0.5）にあること.""" + result = calc_spatial_uniformity(decaying_luminance) + # 中心明・周辺暗なので最小輝度は周辺側にあるはず + assert result["radial_min_distance"] > 0.5 + + def test_radial_min_max_ratio_is_consistent_with_radial_profile( + self, sample_luminance: numpy.ndarray + ) -> None: + """仕様: radial_min_max_ratio が radial_profile の min/max 比と一致すること.""" + result = calc_spatial_uniformity(sample_luminance) + profile = result["radial_profile"] + luminances = profile[:, 1] + expected_ratio = float(numpy.min(luminances)) / float(numpy.max(luminances)) if float(numpy.max(luminances)) != 0.0 else float("inf") + assert result["radial_min_max_ratio"] == pytest.approx(expected_ratio, abs=1e-6) + + def test_new_keys_do_not_overwrite_zone_stats_content( + self, sample_luminance: numpy.ndarray + ) -> None: + """仕様: 新 4 キーの追加が zone_stats の内容を変更しないこと.""" + result = calc_spatial_uniformity(sample_luminance) + zone_stats = result["zone_stats"] + expected_zone_keys = { + "center_mean", "center_std", + "middle_mean", "middle_std", + "periphery_mean", "periphery_std", + "center_periphery_ratio", "gradient_magnitude", + } + assert set(zone_stats.keys()) == expected_zone_keys + + +# --------------------------------------------------------------------------- +# SPATIAL_FIELDNAMES の新カラム テスト +# --------------------------------------------------------------------------- + + +class TestSpatialFieldnamesNewColumns: + """SPATIAL_FIELDNAMES に新カラムが追加された仕様検証テスト群.""" + + def test_spatial_fieldnames_contains_radial_min_max_ratio(self) -> None: + """仕様: SPATIAL_FIELDNAMES に 'radial_min_max_ratio' が含まれること.""" + assert "radial_min_max_ratio" in SPATIAL_FIELDNAMES + + def test_spatial_fieldnames_contains_radial_min_distance(self) -> None: + """仕様: SPATIAL_FIELDNAMES に 'radial_min_distance' が含まれること.""" + assert "radial_min_distance" in SPATIAL_FIELDNAMES + + def test_spatial_fieldnames_still_contains_base_columns(self) -> None: + """仕様: SPATIAL_FIELDNAMES が既存の 6 基本カラムをすべて含むこと（削除・改名なし）.""" + base_fields = [ + "image_name", + "center_mean", + "middle_mean", + "periphery_mean", + "center_periphery_ratio", + "gradient_magnitude", + ] + for field in base_fields: + assert field in SPATIAL_FIELDNAMES, ( + f"必須フィールド '{field}' が SPATIAL_FIELDNAMES から消えている（削除・改名は禁止）" + ) + + def test_spatial_fieldnames_has_at_least_8_columns(self) -> None: + """仕様: SPATIAL_FIELDNAMES が基本 6 + 新規 2 = 最低 8 カラムを持つこと.""" + assert len(SPATIAL_FIELDNAMES) >= 8 + + +# --------------------------------------------------------------------------- +# export_spatial_summary の新指標書き出し テスト +# --------------------------------------------------------------------------- + + +class TestExportSpatialSummaryNewMetrics: + """export_spatial_summary が新指標を書き出せる仕様検証テスト群.""" + + @pytest.fixture + def sample_spatial_results_with_new_metrics(self) -> list[dict]: + """新 2 指標（radial_min_max_ratio / radial_min_distance）を含む空間解析結果リスト.""" + return [ + { + "image_name": "image_001", + "center_mean": 180.0, + "middle_mean": 165.0, + "periphery_mean": 140.0, + "center_periphery_ratio": 1.29, + "gradient_magnitude": 22.2, + "radial_min_max_ratio": 0.75, + "radial_min_distance": 0.95, + }, + { + "image_name": "image_002", + "center_mean": 200.0, + "middle_mean": 190.0, + "periphery_mean": 170.0, + "center_periphery_ratio": 1.18, + "gradient_magnitude": 15.0, + "radial_min_max_ratio": 0.82, + "radial_min_distance": 0.90, + }, + ] + + def test_csv_contains_radial_min_max_ratio_column( + self, + sample_spatial_results_with_new_metrics: list[dict], + tmp_path: Path, + ) -> None: + """仕様: 出力 CSV のヘッダーに 'radial_min_max_ratio' が含まれること.""" + output_path = str(tmp_path / "spatial_new.csv") + export_spatial_summary(sample_spatial_results_with_new_metrics, output_path) + + with open(output_path, encoding="utf-8") as f: + reader = csv.DictReader(f) + fieldnames = reader.fieldnames + assert "radial_min_max_ratio" in fieldnames + + def test_csv_contains_radial_min_distance_column( + self, + sample_spatial_results_with_new_metrics: list[dict], + tmp_path: Path, + ) -> None: + """仕様: 出力 CSV のヘッダーに 'radial_min_distance' が含まれること.""" + output_path = str(tmp_path / "spatial_new.csv") + export_spatial_summary(sample_spatial_results_with_new_metrics, output_path) + + with open(output_path, encoding="utf-8") as f: + reader = csv.DictReader(f) + fieldnames = reader.fieldnames + assert "radial_min_distance" in fieldnames + + def test_csv_radial_min_max_ratio_values_are_written_correctly( + self, + sample_spatial_results_with_new_metrics: list[dict], + tmp_path: Path, + ) -> None: + """仕様: radial_min_max_ratio の値が正しく書き込まれること.""" + output_path = str(tmp_path / "spatial_new.csv") + export_spatial_summary(sample_spatial_results_with_new_metrics, output_path) + + with open(output_path, encoding="utf-8") as f: + reader = csv.DictReader(f) + rows = list(reader) + + assert float(rows[0]["radial_min_max_ratio"]) == pytest.approx(0.75) + assert float(rows[1]["radial_min_max_ratio"]) == pytest.approx(0.82) + + def test_csv_radial_min_distance_values_are_written_correctly( + self, + sample_spatial_results_with_new_metrics: list[dict], + tmp_path: Path, + ) -> None: + """仕様: radial_min_distance の値が正しく書き込まれること.""" + output_path = str(tmp_path / "spatial_new.csv") + export_spatial_summary(sample_spatial_results_with_new_metrics, output_path) + + with open(output_path, encoding="utf-8") as f: + reader = csv.DictReader(f) + rows = list(reader) + + assert float(rows[0]["radial_min_distance"]) == pytest.approx(0.95) + assert float(rows[1]["radial_min_distance"]) == pytest.approx(0.90) + + def test_csv_fieldnames_match_spatial_fieldnames_constant( + self, + sample_spatial_results_with_new_metrics: list[dict], + tmp_path: Path, + ) -> None: + """仕様: CSV ヘッダーが SPATIAL_FIELDNAMES 定数と完全一致すること.""" + output_path = str(tmp_path / "spatial_new.csv") + export_spatial_summary(sample_spatial_results_with_new_metrics, output_path) + + with open(output_path, encoding="utf-8") as f: + reader = csv.DictReader(f) + fieldnames = reader.fieldnames + assert list(fieldnames) == SPATIAL_FIELDNAMES + + +# --------------------------------------------------------------------------- +# calc_batch_statistics の新指標集計 テスト +# --------------------------------------------------------------------------- + + +class TestCalcBatchStatisticsNewMetrics: + """calc_batch_statistics が新 2 指標（radial_min_max_ratio / radial_min_distance）を + 集計する仕様検証テスト群.""" + + @pytest.fixture + def results_with_radial_metrics(self) -> list[dict]: + """radial_min_max_ratio / radial_min_distance を含む 2 画像分の結果リスト.""" + return [ + { + "image_name": "image_001", + "mean": 200.0, + "std": 10.0, + "cov": 0.05, + "max_min_ratio": 1.2, + "max": 220.0, + "min": 180.0, + "center_mean": 180.0, + "middle_mean": 165.0, + "periphery_mean": 140.0, + "center_periphery_ratio": 1.286, + "gradient_magnitude": 22.2, + "radial_min_max_ratio": 0.75, + "radial_min_distance": 0.95, + }, + { + "image_name": "image_002", + "mean": 210.0, + "std": 20.0, + "cov": 0.095, + "max_min_ratio": 1.4, + "max": 240.0, + "min": 160.0, + "center_mean": 200.0, + "middle_mean": 185.0, + "periphery_mean": 160.0, + "center_periphery_ratio": 1.25, + "gradient_magnitude": 20.0, + "radial_min_max_ratio": 0.80, + "radial_min_distance": 0.90, + }, + ] + + def test_spatial_contains_radial_min_max_ratio( + self, results_with_radial_metrics: list[dict] + ) -> None: + """仕様: calc_batch_statistics の spatial 部に 'radial_min_max_ratio' が含まれること.""" + from src.export.exporter import calc_batch_statistics + + result = calc_batch_statistics(results_with_radial_metrics) + assert "radial_min_max_ratio" in result["spatial"] + + def test_spatial_contains_radial_min_distance( + self, results_with_radial_metrics: list[dict] + ) -> None: + """仕様: calc_batch_statistics の spatial 部に 'radial_min_distance' が含まれること.""" + from src.export.exporter import calc_batch_statistics + + result = calc_batch_statistics(results_with_radial_metrics) + assert "radial_min_distance" in result["spatial"] + + def test_radial_min_max_ratio_mean_is_correct( + self, results_with_radial_metrics: list[dict] + ) -> None: + """仕様: radial_min_max_ratio の mean が (0.75 + 0.80) / 2 = 0.775 であること.""" + from src.export.exporter import calc_batch_statistics + + result = calc_batch_statistics(results_with_radial_metrics) + assert result["spatial"]["radial_min_max_ratio"]["mean"] == pytest.approx(0.775) + + def test_radial_min_distance_mean_is_correct( + self, results_with_radial_metrics: list[dict] + ) -> None: + """仕様: radial_min_distance の mean が (0.95 + 0.90) / 2 = 0.925 であること.""" + from src.export.exporter import calc_batch_statistics + + result = calc_batch_statistics(results_with_radial_metrics) + assert result["spatial"]["radial_min_distance"]["mean"] == pytest.approx(0.925) + + def test_radial_min_max_ratio_std_is_population_std( + self, results_with_radial_metrics: list[dict] + ) -> None: + """仕様: radial_min_max_ratio の std が母集団標準偏差（ddof=0）で算出されること.""" + from src.export.exporter import calc_batch_statistics + + result = calc_batch_statistics(results_with_radial_metrics) + expected_std = float(np.std([0.75, 0.80], ddof=0)) + assert result["spatial"]["radial_min_max_ratio"]["std"] == pytest.approx(expected_std) + + def test_radial_min_max_ratio_has_five_stat_subkeys( + self, results_with_radial_metrics: list[dict] + ) -> None: + """仕様: radial_min_max_ratio が mean/std/min/max/cv の 5 サブキーを持つこと.""" + from src.export.exporter import calc_batch_statistics + + result = calc_batch_statistics(results_with_radial_metrics) + expected_subkeys = {"mean", "std", "min", "max", "cv"} + assert expected_subkeys == set( + result["spatial"]["radial_min_max_ratio"].keys() + ) + + def test_radial_min_distance_has_five_stat_subkeys( + self, results_with_radial_metrics: list[dict] + ) -> None: + """仕様: radial_min_distance が mean/std/min/max/cv の 5 サブキーを持つこと.""" + from src.export.exporter import calc_batch_statistics + + result = calc_batch_statistics(results_with_radial_metrics) + expected_subkeys = {"mean", "std", "min", "max", "cv"} + assert expected_subkeys == set( + result["spatial"]["radial_min_distance"].keys() + ) + + +# --------------------------------------------------------------------------- +# plot_radial_profile の最大/最小マーカー テスト +# --------------------------------------------------------------------------- + + +class TestPlotRadialProfileMinMaxMarkers: + """plot_radial_profile に最大/最小マーカーと注記が追加された仕様検証テスト群. + + テスト方針: 可視化テストは「出力ファイルが生成されること程度でよい」（GUIDE_08）． + ここではファイル生成確認と、既知のプロファイルで例外が発生しないことを確認する． + """ + + @pytest.fixture(autouse=True) + def _setup_mpl(self) -> None: + """GUI なし環境でも動作するバックエンドを設定する.""" + import matplotlib + matplotlib.use("Agg") + + @pytest.fixture + def monotone_profile(self) -> numpy.ndarray: + """単調減衰の 20 点動径プロファイル（min/max が両端に存在）.""" + distances = numpy.linspace(0.025, 0.975, 20) + luminances = numpy.linspace(200.0, 100.0, 20) + return numpy.column_stack([distances, luminances]) + + @pytest.fixture + def non_monotone_profile(self) -> numpy.ndarray: + """非単調の 20 点動径プロファイル（中間に極値が存在）.""" + distances = numpy.linspace(0.025, 0.975, 20) + # 中間に谷があるプロファイル + luminances = numpy.array( + [200.0, 190.0, 180.0, 170.0, 160.0, 150.0, 140.0, 130.0, 120.0, 110.0, + 80.0, 110.0, 120.0, 130.0, 140.0, 150.0, 160.0, 170.0, 180.0, 190.0], + dtype=numpy.float64, + ) + return numpy.column_stack([distances, luminances]) + + @pytest.fixture + def uniform_profile(self) -> numpy.ndarray: + """均一の 20 点動径プロファイル（min=max の境界ケース）.""" + distances = numpy.linspace(0.025, 0.975, 20) + luminances = numpy.full(20, 150.0) + return numpy.column_stack([distances, luminances]) + + def test_output_file_is_created_with_monotone_profile( + self, monotone_profile: numpy.ndarray, tmp_path: Path + ) -> None: + """仕様: 単調減衰プロファイルで出力ファイルが生成されること.""" + from src.visualization.plotter import plot_radial_profile + + output_path = str(tmp_path / "radial_monotone.png") + plot_radial_profile(monotone_profile, output_path) + assert Path(output_path).exists() + assert Path(output_path).stat().st_size > 0 + + def test_output_file_is_created_with_non_monotone_profile( + self, non_monotone_profile: numpy.ndarray, tmp_path: Path + ) -> None: + """仕様: 非単調プロファイルでも出力ファイルが生成されること（例外なし）.""" + from src.visualization.plotter import plot_radial_profile + + output_path = str(tmp_path / "radial_non_monotone.png") + plot_radial_profile(non_monotone_profile, output_path) + assert Path(output_path).exists() + + def test_output_file_is_created_with_uniform_profile( + self, uniform_profile: numpy.ndarray, tmp_path: Path + ) -> None: + """仕様: min=max の均一プロファイルでもゼロ除算なく出力ファイルが生成されること.""" + from src.visualization.plotter import plot_radial_profile + + output_path = str(tmp_path / "radial_uniform.png") + # min=max → ratio=1.0 のケース（ゼロ除算は発生しない） + plot_radial_profile(uniform_profile, output_path) + assert Path(output_path).exists() + + def test_signature_is_unchanged(self) -> None: + """仕様: plot_radial_profile のシグネチャが不変であること（引数 radial_profile, output_path）.""" + import inspect + from src.visualization.plotter import plot_radial_profile + + sig = inspect.signature(plot_radial_profile) + params = list(sig.parameters.keys()) + assert params == ["radial_profile", "output_path"], ( + f"シグネチャが変更されている: {params}" + ) diff --git a/tests/analysis/test_spatial.py b/tests/analysis/test_spatial.py index c9f9277..c0d5193 100644 --- a/tests/analysis/test_spatial.py +++ b/tests/analysis/test_spatial.py @@ -379,9 +379,16 @@ assert "zone_map" in result def test_return_value_has_exactly_3_keys(self, sample_luminance) -> None: - """正常: 戻り値のキー数が 3 であること.""" + """正常: 戻り値に最低 3 つの基本キー（zone_stats/radial_profile/zone_map）が存在すること. + + 仕様変更（動径 min/max 比の追加）によりトップレベルキー数は 3 超になりうる． + 基本 3 キーの存在を保証し，追加キーを許容する形に修正する． + """ result = calc_spatial_uniformity(sample_luminance) - assert len(result) == 3 + assert "zone_stats" in result + assert "radial_profile" in result + assert "zone_map" in result + assert len(result) >= 3 def test_zone_stats_is_dict(self, sample_luminance) -> None: """正常: zone_stats が dict 型であること.""" diff --git a/tests/export/test_exporter.py b/tests/export/test_exporter.py index f75ee56..9167c2d 100644 --- a/tests/export/test_exporter.py +++ b/tests/export/test_exporter.py @@ -340,8 +340,12 @@ assert float(second["gradient_magnitude"]) == pytest.approx(15.0) def test_spatial_fieldnames_constant_has_correct_keys(self) -> None: - """正常: SPATIAL_FIELDNAMES 定数が期待されるキーを持つこと.""" - expected = [ + """正常: SPATIAL_FIELDNAMES 定数が既存の基本キーをすべて含むこと. + + 仕様変更（動径 min/max 比の追加）により新カラムが追加されるため， + 既存の 6 カラムが含まれていることを確認し，追加カラムを許容する． + """ + base_fields = [ "image_name", "center_mean", "middle_mean", @@ -349,7 +353,9 @@ "center_periphery_ratio", "gradient_magnitude", ] - assert SPATIAL_FIELDNAMES == expected + for field in base_fields: + assert field in SPATIAL_FIELDNAMES, f"必須フィールド '{field}' が SPATIAL_FIELDNAMES に含まれていない" + assert len(SPATIAL_FIELDNAMES) >= len(base_fields) def test_creates_parent_directory_automatically( self, sample_spatial_results: list[dict], tmp_path: Path @@ -412,7 +418,10 @@ @pytest.fixture def two_image_results(self) -> list[dict]: - """テスト用の 2 画像分の解析結果リストを返す fixture.""" + """テスト用の 2 画像分の解析結果リストを返す fixture. + + 仕様変更（動径 min/max 比の追加）に対応し radial_min_max_ratio / radial_min_distance を追加． + """ return [ { "image_name": "image_001", @@ -427,6 +436,8 @@ "periphery_mean": 140.0, "center_periphery_ratio": 1.286, "gradient_magnitude": 22.2, + "radial_min_max_ratio": 0.75, + "radial_min_distance": 0.95, }, { "image_name": "image_002", @@ -441,6 +452,8 @@ "periphery_mean": 160.0, "center_periphery_ratio": 1.25, "gradient_magnitude": 20.0, + "radial_min_max_ratio": 0.80, + "radial_min_distance": 0.90, }, ] @@ -464,16 +477,20 @@ def test_spatial_contains_exactly_five_metrics( self, two_image_results: list[dict] ) -> None: - """正常: spatial 部に 5 指標のみが含まれること.""" + """正常: spatial 部に基本 5 指標が含まれること. + + 仕様変更（動径 min/max 比の追加）により spatial キーは 5 超になりうる． + 基本 5 指標の存在を確認し，追加指標を許容する形に修正する． + """ result = calc_batch_statistics(two_image_results) - expected_metrics = { + base_metrics = { "center_mean", "middle_mean", "periphery_mean", "center_periphery_ratio", "gradient_magnitude", } - assert expected_metrics == set(result["spatial"].keys()) + assert base_metrics.issubset(set(result["spatial"].keys())) def test_each_metric_has_five_stat_subkeys( self, two_image_results: list[dict] @@ -620,6 +637,8 @@ "periphery_mean": 140.0, "center_periphery_ratio": 1.286, "gradient_magnitude": 22.2, + "radial_min_max_ratio": 0.75, + "radial_min_distance": 0.95, } ] result = calc_batch_statistics(single) @@ -641,6 +660,8 @@ "periphery_mean": 140.0, "center_periphery_ratio": 1.286, "gradient_magnitude": 22.2, + "radial_min_max_ratio": 0.75, + "radial_min_distance": 0.95, } ] result = calc_batch_statistics(single) @@ -662,6 +683,8 @@ "periphery_mean": 140.0, "center_periphery_ratio": 1.286, "gradient_magnitude": 22.2, + "radial_min_max_ratio": 0.75, + "radial_min_distance": 0.95, } ] result = calc_batch_statistics(single) @@ -689,6 +712,8 @@ "periphery_mean": m - 10.0, "center_periphery_ratio": 1.1, "gradient_magnitude": 5.0, + "radial_min_max_ratio": 0.8, + "radial_min_distance": 0.9, } for i, m in enumerate([100.0, 200.0, 300.0]) ] @@ -712,6 +737,8 @@ "periphery_mean": 140.0, "center_periphery_ratio": 1.286, "gradient_magnitude": 22.2, + "radial_min_max_ratio": 0.75, + "radial_min_distance": 0.95, } for i in range(3) ] @@ -886,7 +913,11 @@ ) def test_integration_calc_then_export(self, tmp_path: Path) -> None: - """統合: calc_batch_statistics の結果を export_batch_statistics で出力できること.""" + """統合: calc_batch_statistics の結果を export_batch_statistics で出力できること. + + 仕様変更（動径 min/max 比の追加）により行数は 9 以上になりうる． + 基本指標の存在を確認し，行数は >= 9 に修正する． + """ all_results = [ { "image_name": "image_001", @@ -901,6 +932,8 @@ "periphery_mean": 140.0, "center_periphery_ratio": 1.286, "gradient_magnitude": 22.2, + "radial_min_max_ratio": 0.75, + "radial_min_distance": 0.95, }, { "image_name": "image_002", @@ -915,6 +948,8 @@ "periphery_mean": 160.0, "center_periphery_ratio": 1.25, "gradient_magnitude": 20.0, + "radial_min_max_ratio": 0.80, + "radial_min_distance": 0.90, }, ] stats = calc_batch_statistics(all_results) @@ -926,7 +961,8 @@ reader = csv.DictReader(f) rows = list(reader) - assert len(rows) == 9 # uniformity 4 + spatial 5 + # uniformity 4 + spatial 5 以上（動径 min/max 比の追加で 7 になりうる） + assert len(rows) >= 9 statistic_names = {row["statistic"] for row in rows} assert "mean" in statistic_names assert "cov" in statistic_names diff --git a/tests/io/test_dng_loader.py b/tests/io/test_dng_loader.py new file mode 100644 index 0000000..7ce1edf --- /dev/null +++ b/tests/io/test_dng_loader.py @@ -0,0 +1,437 @@ +"""dng_loader.py の単体テスト. + +仕様 (TECH_05_MiniTiasEvaluation_DNG対応要求仕様.md): + - load_image_dng: DNG ファイルを読み込み numpy.ndarray として返す + - output_format="rgb_float32": (H, W, 3) float32 linear [0, 1] + - output_format="luma_float32": (H, W) float32 linear [0, 1], Rec.709 係数 + - output_format="rgb_uint8": (H, W, 3) uint8 sRGB OETF 適用後 [0, 255] + - demosaic 既定は "bilinear" + - エラー: FileNotFoundError（存在しないパス）, ValueError（不正 format/demosaic） + - Rec.709 係数 (0.2126, 0.7152, 0.0722) は uniformity.py の REC709_COEFF_* と一致すること + +テスト方針 (GUIDE_08_テスト方針.md): + - pytest を使用 + - サンプル DNG は .gitignore 対象のため不在時は pytest.mark.skipif でスキップ + - 合成 DNG（rawpy モック）または実 DNG で検証する +""" + +from pathlib import Path + +import numpy +import numpy as np +import pytest + +# サンプル DNG パス（.gitignore 対象のため不在環境では実 DNG テストをスキップ） +_SAMPLE_DNG_PATH = ( + Path(__file__).parent.parent.parent + / "data" + / "minitias" + / "quantitative" + / "MiniTIAS_QM_20260601_102753.dng" +) +_DNG_AVAILABLE = _SAMPLE_DNG_PATH.exists() + +# Rec.709 係数（仕様: uniformity.py の REC709_COEFF_* と一致） +_REC709_R = 0.2126 +_REC709_G = 0.7152 +_REC709_B = 0.0722 + + +# --------------------------------------------------------------------------- +# エラーパス テスト（DNG 不要 — パス検証のみ） +# --------------------------------------------------------------------------- + + +class TestLoadImageDngErrors: + """load_image_dng のエラー送出テスト群.""" + + def test_raises_file_not_found_for_nonexistent_path(self) -> None: + """仕様 V2 / エラー仕様: 存在しないパスで FileNotFoundError が送出されること.""" + from src.io.dng_loader import load_image_dng + + with pytest.raises(FileNotFoundError): + load_image_dng("/nonexistent/path/image.dng") + + def test_file_not_found_message_contains_path(self, tmp_path: Path) -> None: + """エラー仕様: FileNotFoundError のメッセージにパスが含まれること.""" + from src.io.dng_loader import load_image_dng + + missing = str(tmp_path / "missing.dng") + with pytest.raises(FileNotFoundError, match="missing.dng"): + load_image_dng(missing) + + def test_raises_value_error_for_invalid_output_format(self, tmp_path: Path) -> None: + """エラー仕様: 不正な output_format で ValueError が送出されること. + + 仕様では rgb_float32 / luma_float32 / rgb_uint8 の 3 種のみ有効． + """ + from src.io.dng_loader import load_image_dng + + # 実在するダミーファイルを作成（パス存在チェック通過のため） + dummy = tmp_path / "dummy.dng" + dummy.write_bytes(b"FAKE_DNG_CONTENT") + + with pytest.raises(ValueError): + load_image_dng(str(dummy), output_format="invalid_format") + + def test_raises_value_error_for_invalid_demosaic(self, tmp_path: Path) -> None: + """エラー仕様: 不正な demosaic 値で ValueError が送出されること. + + 仕様では nearest / bilinear / ahd の 3 種のみ有効． + """ + from src.io.dng_loader import load_image_dng + + dummy = tmp_path / "dummy.dng" + dummy.write_bytes(b"FAKE_DNG_CONTENT") + + with pytest.raises(ValueError): + load_image_dng(str(dummy), demosaic="invalid_demosaic") + + def test_value_error_for_invalid_format_message_is_descriptive( + self, tmp_path: Path + ) -> None: + """エラー仕様: ValueError メッセージに不正な値が含まれること.""" + from src.io.dng_loader import load_image_dng + + dummy = tmp_path / "dummy.dng" + dummy.write_bytes(b"FAKE_DNG_CONTENT") + + with pytest.raises(ValueError, match="bad_format"): + load_image_dng(str(dummy), output_format="bad_format") + + def test_invalid_output_format_rejected_before_file_read( + self, tmp_path: Path + ) -> None: + """仕様: 不正な output_format は rawpy 読み込み前にバリデーションされること. + + ファイルが存在するが内容が DNG でない場合でも ValueError が先に出ること． + （存在するが不正な内容のファイルは rawpy で ValueError になる可能性があるが， + output_format バリデーションはその前に実行されること） + """ + from src.io.dng_loader import load_image_dng + + dummy = tmp_path / "dummy.dng" + dummy.write_bytes(b"NOT_A_DNG") + + with pytest.raises(ValueError): + load_image_dng(str(dummy), output_format="unknown_format") + + +# --------------------------------------------------------------------------- +# output_format 値ガード テスト（DNG 不要） +# --------------------------------------------------------------------------- + + +class TestOutputFormatValidation: + """output_format バリデーション専用テスト群. + + 仕様: 有効な output_format は rgb_float32 / luma_float32 / rgb_uint8 の 3 種のみ． + """ + + @pytest.mark.parametrize( + "invalid_format", + ["RGB", "float32", "uint8", "luma", "rgb", "luma_uint8", ""], + ) + def test_invalid_format_raises_value_error( + self, invalid_format: str, tmp_path: Path + ) -> None: + """エラー仕様: 有効でない output_format は ValueError を送出すること.""" + from src.io.dng_loader import load_image_dng + + dummy = tmp_path / "dummy.dng" + dummy.write_bytes(b"FAKE") + + with pytest.raises(ValueError): + load_image_dng(str(dummy), output_format=invalid_format) + + @pytest.mark.parametrize( + "invalid_demosaic", + ["linear", "LINEAR", "adaptive", "vng", ""], + ) + def test_invalid_demosaic_raises_value_error( + self, invalid_demosaic: str, tmp_path: Path + ) -> None: + """エラー仕様: 有効でない demosaic は ValueError を送出すること.""" + from src.io.dng_loader import load_image_dng + + dummy = tmp_path / "dummy.dng" + dummy.write_bytes(b"FAKE") + + with pytest.raises(ValueError): + load_image_dng(str(dummy), demosaic=invalid_demosaic) + + +# --------------------------------------------------------------------------- +# 実 DNG テスト（DNG ファイルが存在する環境のみ） +# --------------------------------------------------------------------------- + +_skip_if_no_dng = pytest.mark.skipif( + not _DNG_AVAILABLE, + reason=f"サンプル DNG が存在しない: {_SAMPLE_DNG_PATH}", +) + + +@_skip_if_no_dng +class TestLoadImageDngRgbFloat32: + """output_format="rgb_float32" の仕様検証テスト群.""" + + @pytest.fixture + def rgb_float32_result(self) -> numpy.ndarray: + """rgb_float32 形式で DNG を読み込んだ結果を返す fixture.""" + from src.io.dng_loader import load_image_dng + + return load_image_dng(str(_SAMPLE_DNG_PATH), output_format="rgb_float32") + + def test_shape_is_3d_with_3_channels( + self, rgb_float32_result: numpy.ndarray + ) -> None: + """仕様: rgb_float32 の shape が (H, W, 3) であること.""" + assert rgb_float32_result.ndim == 3 + assert rgb_float32_result.shape[2] == 3 + + def test_dtype_is_float32(self, rgb_float32_result: numpy.ndarray) -> None: + """仕様: rgb_float32 の dtype が float32 であること.""" + assert rgb_float32_result.dtype == numpy.float32 + + def test_values_are_non_negative(self, rgb_float32_result: numpy.ndarray) -> None: + """仕様: rgb_float32 の値が 0 以上であること（linear raw, black_level 補正済み）.""" + assert numpy.all(rgb_float32_result >= 0.0) + + def test_values_are_mostly_within_0_to_1( + self, rgb_float32_result: numpy.ndarray + ) -> None: + """仕様: rgb_float32 の値がおおむね [0, 1] 範囲内であること. + + 仕様では「飽和は 1.0 を超えることがある（クリップしない）」とあるが， + 通常の撮影では大部分のピクセルが 1.0 以下のはず． + 99 パーセンタイルが 1.0 以下であることを確認する． + """ + p99 = numpy.percentile(rgb_float32_result, 99) + assert p99 <= 1.0, f"99 パーセンタイルが 1.0 超: {p99}" + + def test_mean_value_is_positive_and_reasonable( + self, rgb_float32_result: numpy.ndarray + ) -> None: + """仕様 V1 系: CoV > 0 等の妥当性確認 — 平均値が正の有限値であること.""" + mean_val = float(numpy.mean(rgb_float32_result)) + assert mean_val > 0.0 + assert numpy.isfinite(mean_val) + + def test_std_is_positive(self, rgb_float32_result: numpy.ndarray) -> None: + """仕様 V1 系: 画像内に輝度のバラツキが存在すること（CoV > 0 に相当）.""" + std_val = float(numpy.std(rgb_float32_result)) + assert std_val > 0.0 + + +@_skip_if_no_dng +class TestLoadImageDngLumaFloat32: + """output_format="luma_float32" の仕様検証テスト群.""" + + @pytest.fixture + def luma_and_rgb(self) -> tuple[numpy.ndarray, numpy.ndarray]: + """luma_float32 と rgb_float32 の両方を読み込んで返す fixture.""" + from src.io.dng_loader import load_image_dng + + luma = load_image_dng(str(_SAMPLE_DNG_PATH), output_format="luma_float32") + rgb = load_image_dng(str(_SAMPLE_DNG_PATH), output_format="rgb_float32") + return luma, rgb + + def test_shape_is_2d( + self, luma_and_rgb: tuple[numpy.ndarray, numpy.ndarray] + ) -> None: + """仕様: luma_float32 の shape が (H, W) の 2 次元配列であること.""" + luma, _ = luma_and_rgb + assert luma.ndim == 2 + + def test_dtype_is_float32( + self, luma_and_rgb: tuple[numpy.ndarray, numpy.ndarray] + ) -> None: + """仕様: luma_float32 の dtype が float32 であること.""" + luma, _ = luma_and_rgb + assert luma.dtype == numpy.float32 + + def test_shape_matches_rgb_hw( + self, luma_and_rgb: tuple[numpy.ndarray, numpy.ndarray] + ) -> None: + """仕様: luma_float32 の shape が rgb_float32 の (H, W) と一致すること.""" + luma, rgb = luma_and_rgb + assert luma.shape == rgb.shape[:2] + + def test_values_are_non_negative( + self, luma_and_rgb: tuple[numpy.ndarray, numpy.ndarray] + ) -> None: + """仕様: luma_float32 の値が 0 以上であること.""" + luma, _ = luma_and_rgb + assert numpy.all(luma >= 0.0) + + def test_luma_is_rec709_weighted_sum_of_rgb( + self, luma_and_rgb: tuple[numpy.ndarray, numpy.ndarray] + ) -> None: + """仕様: luma_float32 が Rec.709 係数 (0.2126, 0.7152, 0.0722) で rgb_float32 から + 導出した輝度と一致すること. + + luma = 0.2126 * R + 0.7152 * G + 0.0722 * B + この係数は uniformity.py の REC709_COEFF_* と一致する． + """ + luma, rgb = luma_and_rgb + expected_luma = ( + _REC709_R * rgb[:, :, 0] + + _REC709_G * rgb[:, :, 1] + + _REC709_B * rgb[:, :, 2] + ).astype(numpy.float32) + numpy.testing.assert_allclose( + luma, expected_luma, rtol=1e-5, atol=1e-6, + err_msg="luma_float32 が Rec.709 係数による rgb_float32 の加重和と一致しない", + ) + + def test_mean_value_is_positive_and_finite( + self, luma_and_rgb: tuple[numpy.ndarray, numpy.ndarray] + ) -> None: + """仕様 V1 系: luma_float32 の平均値が正の有限値であること.""" + luma, _ = luma_and_rgb + mean_val = float(numpy.mean(luma)) + assert mean_val > 0.0 + assert numpy.isfinite(mean_val) + + +@_skip_if_no_dng +class TestLoadImageDngRgbUint8: + """output_format="rgb_uint8" の仕様検証テスト群.""" + + @pytest.fixture + def rgb_uint8_result(self) -> numpy.ndarray: + """rgb_uint8 形式で DNG を読み込んだ結果を返す fixture.""" + from src.io.dng_loader import load_image_dng + + return load_image_dng(str(_SAMPLE_DNG_PATH), output_format="rgb_uint8") + + def test_shape_is_3d_with_3_channels( + self, rgb_uint8_result: numpy.ndarray + ) -> None: + """仕様: rgb_uint8 の shape が (H, W, 3) であること.""" + assert rgb_uint8_result.ndim == 3 + assert rgb_uint8_result.shape[2] == 3 + + def test_dtype_is_uint8(self, rgb_uint8_result: numpy.ndarray) -> None: + """仕様: rgb_uint8 の dtype が uint8 であること.""" + assert rgb_uint8_result.dtype == numpy.uint8 + + def test_values_are_in_0_to_255_range( + self, rgb_uint8_result: numpy.ndarray + ) -> None: + """仕様: rgb_uint8 の値が [0, 255] の範囲内であること（uint8 なので常に満たす）.""" + assert numpy.all(rgb_uint8_result >= 0) + assert numpy.all(rgb_uint8_result <= 255) + + def test_mean_value_is_positive_and_finite( + self, rgb_uint8_result: numpy.ndarray + ) -> None: + """仕様 V1 系: rgb_uint8 の平均値が正の有限値であること（CoV > 0 等の妥当性）.""" + mean_val = float(numpy.mean(rgb_uint8_result)) + assert mean_val > 0.0 + assert numpy.isfinite(mean_val) + + +@_skip_if_no_dng +class TestLoadImageDngDemosaic: + """demosaic 引数の仕様検証テスト群.""" + + def test_default_demosaic_is_bilinear_callable(self) -> None: + """仕様: 既定 demosaic="bilinear" で正常に読み込めること.""" + from src.io.dng_loader import load_image_dng + + # 引数なし（既定値 bilinear）で例外が発生しないこと + result = load_image_dng(str(_SAMPLE_DNG_PATH)) + assert isinstance(result, numpy.ndarray) + + def test_demosaic_ahd_does_not_raise(self) -> None: + """仕様: demosaic="ahd" で例外が発生しないこと.""" + from src.io.dng_loader import load_image_dng + + result = load_image_dng(str(_SAMPLE_DNG_PATH), demosaic="ahd") + assert isinstance(result, numpy.ndarray) + assert result.ndim == 3 # rgb_float32 既定 + + def test_demosaic_nearest_does_not_raise(self) -> None: + """仕様: demosaic="nearest" で例外が発生しないこと.""" + from src.io.dng_loader import load_image_dng + + result = load_image_dng(str(_SAMPLE_DNG_PATH), demosaic="nearest") + assert isinstance(result, numpy.ndarray) + + def test_demosaic_bilinear_explicit_does_not_raise(self) -> None: + """仕様: demosaic="bilinear" を明示的に指定しても例外が発生しないこと.""" + from src.io.dng_loader import load_image_dng + + result = load_image_dng(str(_SAMPLE_DNG_PATH), demosaic="bilinear") + assert isinstance(result, numpy.ndarray) + + def test_bilinear_and_ahd_return_same_shape(self) -> None: + """仕様: bilinear と ahd で同一 shape の結果が返ること（センサ解像度が同一のため）.""" + from src.io.dng_loader import load_image_dng + + bilinear = load_image_dng( + str(_SAMPLE_DNG_PATH), demosaic="bilinear", output_format="rgb_float32" + ) + ahd = load_image_dng( + str(_SAMPLE_DNG_PATH), demosaic="ahd", output_format="rgb_float32" + ) + assert bilinear.shape == ahd.shape + + +@_skip_if_no_dng +class TestLoadImageDngLinearity: + """線形性（linear ドメイン）の仕様検証テスト群. + + 仕様: rgb_float32 の各チャンネルが入射光量に比例すること（カラーマトリクス非適用）． + 直接的な「減光プロファイル vs 生 Bayer 比較」は実機依存のため， + ここでは proxy 検証（no_auto_bright + gamma=(1,1) の確認）を行う． + """ + + def test_rgb_float32_and_luma_float32_have_consistent_brightness(self) -> None: + """仕様 線形性: rgb_float32 から計算した Rec.709 luma と luma_float32 が一致すること. + + これは linear ドメインでの輝度計算の一貫性を確認する検証である． + """ + from src.io.dng_loader import load_image_dng + + rgb = load_image_dng(str(_SAMPLE_DNG_PATH), output_format="rgb_float32") + luma = load_image_dng(str(_SAMPLE_DNG_PATH), output_format="luma_float32") + + computed_luma = ( + _REC709_R * rgb[:, :, 0] + + _REC709_G * rgb[:, :, 1] + + _REC709_B * rgb[:, :, 2] + ).astype(numpy.float32) + + numpy.testing.assert_allclose( + luma, computed_luma, rtol=1e-5, atol=1e-6, + ) + + def test_rgb_float32_channels_are_all_positive(self) -> None: + """仕様 線形性: 黒レベル除去後の全チャンネル値が非負であること（線形担保の確認）.""" + from src.io.dng_loader import load_image_dng + + rgb = load_image_dng(str(_SAMPLE_DNG_PATH), output_format="rgb_float32") + # 黒レベル補正済み linear raw なので全値が 0 以上 + assert numpy.all(rgb >= 0.0), "黒レベル補正後に負値が存在する（線形性が崩れている）" + + def test_rgb_float32_green_channel_has_highest_mean(self) -> None: + """仕様 線形性: BGGR Bayer では G チャンネルのサンプリング密度が高く， + 平均輝度が他チャンネルより大きい（または近い）ことを確認する. + + カラーマトリクス非適用（output_color=raw）のため， + G チャンネル（Rec.709 重み 0.7152 が最大）の値が全体で高い傾向がある． + """ + from src.io.dng_loader import load_image_dng + + rgb = load_image_dng(str(_SAMPLE_DNG_PATH), output_format="rgb_float32") + mean_r = float(numpy.mean(rgb[:, :, 0])) + mean_g = float(numpy.mean(rgb[:, :, 1])) + mean_b = float(numpy.mean(rgb[:, :, 2])) + + # G > B であることは BGGR の物理的特性から期待できる + # （R との大小関係は照明スペクトルに依存するため厳密な比較はしない） + assert mean_g > mean_b, ( + f"G チャンネル平均 ({mean_g:.4f}) が B チャンネル平均 ({mean_b:.4f}) 以下" + )