cloudanalyzer 0.4.0__tar.gz → 0.5.0__tar.gz

{cloudanalyzer-0.4.0/cloudanalyzer.egg-info → cloudanalyzer-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudanalyzer
-Version: 0.4.0
+Version: 0.5.0
 Summary: CLI-first QA toolkit for point cloud, trajectory, and 3D perception outputs
 Author: rsasaki0109
 License-Expression: MIT
@@ -22,7 +22,7 @@ Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: open3d>=0.17.0
+Requires-Dist: open3d<0.20,>=0.17.0
 Requires-Dist: numpy>=1.24.0
 Requires-Dist: typer>=0.9.0
 Requires-Dist: matplotlib>=3.7.0
@@ -40,6 +40,17 @@ Provides-Extra: slam
 Requires-Dist: kiss-icp>=1.2.0; extra == "slam"
 Requires-Dist: kiss-slam>=0.0.2; extra == "slam"
 Requires-Dist: small_gicp>=1.0.0; extra == "slam"
+Provides-Extra: ros
+Requires-Dist: rosbags>=0.10; extra == "ros"
+Provides-Extra: gs
+Requires-Dist: torch>=2.0.0; extra == "gs"
+Requires-Dist: gsplat>=1.0.0; extra == "gs"
+Requires-Dist: lpips>=0.1.4; extra == "gs"
+Requires-Dist: dreamsim>=0.2.1; extra == "gs"
+Provides-Extra: perceptual
+Requires-Dist: torch>=2.0.0; extra == "perceptual"
+Requires-Dist: lpips>=0.1.4; extra == "perceptual"
+Requires-Dist: dreamsim>=0.2.1; extra == "perceptual"
 Dynamic: license-file
 
 # CloudAnalyzer

{cloudanalyzer-0.4.0 → cloudanalyzer-0.5.0}/ca/__init__.py

@@ -1,3 +1,3 @@
 """CloudAnalyzer - AI-friendly CLI tool for point cloud analysis."""
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"

{cloudanalyzer-0.4.0 → cloudanalyzer-0.5.0}/ca/batch.py

@@ -5,7 +5,6 @@ from pathlib import Path
 
 from ca.evaluate import evaluate
 from ca.io import SUPPORTED_EXTENSIONS, load_point_cloud
-from ca.info import get_info
 from ca.log import logger
 from ca.pareto import mark_quality_size_recommended
 from ca.trajectory import SUPPORTED_TRAJECTORY_EXTENSIONS, evaluate_trajectory
@@ -216,6 +215,8 @@ def batch_info(directory: str, recursive: bool = False) -> list[dict]:
     Returns:
         List of info dicts for each file found.
     """
+    from ca.info import get_info
+
     files = _find_point_cloud_files(directory, recursive=recursive)
     if not files:
         return []
@@ -331,8 +332,10 @@ def trajectory_batch_evaluate(
     align_rigid: bool = False,
     max_ate: float | None = None,
     max_rpe: float | None = None,
+    max_rpe_rotation_deg: float | None = None,
     max_drift: float | None = None,
     min_coverage: float | None = None,
+    rpe_distances_m: tuple[float, ...] | list[float] | None = None,
 ) -> list[dict]:
     """Evaluate all trajectory files in a directory against matched references."""
     files = _find_trajectory_files(directory, recursive=recursive)
@@ -367,8 +370,10 @@ def trajectory_batch_evaluate(
                 align_rigid=align_rigid,
                 max_ate=max_ate,
                 max_rpe=max_rpe,
+                max_rpe_rotation_deg=max_rpe_rotation_deg,
                 max_drift=max_drift,
                 min_coverage=min_coverage,
+                rpe_distances_m=rpe_distances_m,
             )
             results.append(
                 {
@@ -382,6 +387,9 @@ def trajectory_batch_evaluate(
                     "coverage_ratio": eval_result["matching"]["coverage_ratio"],
                     "ate": eval_result["ate"],
                     "rpe_translation": eval_result["rpe_translation"],
+                    "ate_rotation": eval_result["ate_rotation"],
+                    "rpe_rotation": eval_result["rpe_rotation"],
+                    "rpe_distance": eval_result["rpe_distance"],
                     "drift": eval_result["drift"],
                     "quality_gate": eval_result["quality_gate"],
                     "inspect": _trajectory_inspection_commands(str(f), str(reference_path)),

{cloudanalyzer-0.4.0 → cloudanalyzer-0.5.0}/ca/benchmark.py

@@ -36,12 +36,17 @@ All file paths in the manifest are resolved relative to the manifest file.
 
 from __future__ import annotations
 
+import hashlib
+import json
+import platform
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Mapping
 
 import yaml  # type: ignore[import-untyped]
 
+import ca
+from ca.report_paths import make_paths_portable
 from ca.run_evaluate import evaluate_run
 
 
@@ -50,10 +55,14 @@ GATE_KEYS: tuple[str, ...] = (
     "max_chamfer",
     "max_ate",
     "max_rpe",
+    "max_rpe_rotation_deg",
     "max_drift",
     "min_coverage",
 )
 
+REPORT_BUNDLE_SCHEMA_VERSION = "cloudanalyzer.benchmark_report_bundle.v0.1"
+METRICS_SCHEMA_VERSION = "cloudanalyzer.metrics.v1"
+
 
 @dataclass(frozen=True, slots=True)
 class BenchmarkSequence:
@@ -72,6 +81,7 @@ class BenchmarkSuite:
     description: str
     license: str | None
     source_path: Path
+    dataset: dict[str, Any] = field(default_factory=dict)
     sequences: dict[str, BenchmarkSequence] = field(default_factory=dict)
     gate: dict[str, float] = field(default_factory=dict)
 
@@ -205,6 +215,7 @@ def load_benchmark_suite(path: str | Path) -> BenchmarkSuite:
     )
 
     base_dir = manifest_path.parent
+    dataset = dict(_as_mapping(config.get("dataset"), "dataset"))
     sequences = _parse_sequences(
         config.get("sequences"),
         config.get("sample_outputs"),
@@ -220,6 +231,7 @@ def load_benchmark_suite(path: str | Path) -> BenchmarkSuite:
         sequences=sequences,
         gate=gate,
         source_path=manifest_path,
+        dataset=dataset,
     )
 
 
@@ -271,22 +283,268 @@ def evaluate_benchmark_run(
         max_time_delta=max_time_delta,
         align_origin=align_origin,
         align_rigid=align_rigid,
-        **gate,
+        min_auc=gate.get("min_auc"),
+        max_chamfer=gate.get("max_chamfer"),
+        max_ate=gate.get("max_ate"),
+        max_rpe=gate.get("max_rpe"),
+        max_rpe_rotation_deg=gate.get("max_rpe_rotation_deg"),
+        max_drift=gate.get("max_drift"),
+        min_coverage=gate.get("min_coverage"),
     )
     result["benchmark"] = {
         "suite": suite.name,
         "version": suite.version,
         "sequence": seq.name,
         "source_path": str(suite.source_path),
+        "dataset": dict(suite.dataset),
         "gate": gate,
         "reference": {
             "map": str(seq.reference_map_path),
             "trajectory": str(seq.reference_trajectory_path),
         },
     }
+    result["schema_version"] = METRICS_SCHEMA_VERSION
+    result["runtime"] = {
+        "python": platform.python_version(),
+        "cloudanalyzer": getattr(ca, "__version__", "0.0.0"),
+    }
     return result
 
 
+# ----------------------------------------------------------- report bundle
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as fp:
+        for chunk in iter(lambda: fp.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _file_provenance(path: str | Path, roots: tuple[Path, ...]) -> dict[str, Any]:
+    resolved = Path(path).resolve()
+    portable_path = make_paths_portable(str(resolved), roots)
+    return {
+        "path": portable_path,
+        "sha256": _sha256_file(resolved),
+        "size_bytes": resolved.stat().st_size,
+    }
+
+
+def _bundle_roots(
+    suite: BenchmarkSuite,
+    output_dir: Path,
+    extra_roots: tuple[Path | str, ...] = (),
+) -> tuple[Path, ...]:
+    roots: list[Path] = []
+    for candidate in (
+        Path.cwd(),
+        suite.source_path.parent,
+        output_dir.parent,
+        *extra_roots,
+    ):
+        path = Path(candidate).resolve()
+        if path not in roots:
+            roots.append(path)
+    return tuple(roots)
+
+
+def _bundle_lock_payload(
+    *,
+    suite: BenchmarkSuite,
+    sequence: BenchmarkSequence,
+    result: Mapping[str, Any],
+    output_dir: Path,
+    map_path: str | Path,
+    trajectory_path: str | Path,
+    report_assets: list[str],
+    roots: tuple[Path, ...],
+) -> dict[str, Any]:
+    benchmark = result.get("benchmark")
+    benchmark_map = benchmark if isinstance(benchmark, Mapping) else {}
+    return {
+        "schema_version": REPORT_BUNDLE_SCHEMA_VERSION,
+        "metrics_schema_version": METRICS_SCHEMA_VERSION,
+        "suite": {
+            "name": suite.name,
+            "version": suite.version,
+            "description": suite.description,
+            "license": suite.license,
+            "dataset": dict(suite.dataset),
+            "sequence": sequence.name,
+            "source_path": make_paths_portable(str(suite.source_path), roots),
+        },
+        "gate": dict(benchmark_map.get("gate", suite.gate)),
+        "inputs": {
+            "candidate_map": _file_provenance(map_path, roots),
+            "candidate_trajectory": _file_provenance(trajectory_path, roots),
+            "reference_map": _file_provenance(sequence.reference_map_path, roots),
+            "reference_trajectory": _file_provenance(
+                sequence.reference_trajectory_path,
+                roots,
+            ),
+            "suite_manifest": _file_provenance(suite.source_path, roots),
+        },
+        "outputs": {
+            "metrics": "metrics.json",
+            "summary": "summary.md",
+            "report": "report.html",
+            "report_assets": report_assets,
+            "provenance": "provenance.json",
+            "manifest_lock": "manifest.lock.yaml",
+        },
+        "bundle_path": make_paths_portable(str(output_dir), roots),
+    }
+
+
+def write_benchmark_report_bundle(
+    result: Mapping[str, Any],
+    suite: BenchmarkSuite,
+    output_dir: str | Path,
+    *,
+    map_path: str | Path,
+    trajectory_path: str | Path,
+    sequence: str | None = None,
+    extra_roots: tuple[Path | str, ...] = (),
+) -> dict[str, str]:
+    """Write the standard ``ca benchmark eval --out`` report bundle.
+
+    The bundle is a directory contract intended for CI artifacts and static
+    publishing. It is intentionally simple and inspectable:
+
+    - ``metrics.json``: portable benchmark result JSON
+    - ``summary.md``: PR-comment-ready Markdown summary
+    - ``report.html``: human report
+    - ``manifest.lock.yaml``: suite/gate/input hash lock
+    - ``provenance.json``: machine-readable bundle metadata
+    """
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    roots = _bundle_roots(suite, out.resolve(), extra_roots=extra_roots)
+    sequence_name = sequence
+    benchmark = result.get("benchmark")
+    if sequence_name is None and isinstance(benchmark, Mapping):
+        raw_sequence = benchmark.get("sequence")
+        if isinstance(raw_sequence, str):
+            sequence_name = raw_sequence
+    seq = suite.resolve_sequence(sequence_name)
+
+    portable_result = make_paths_portable(dict(result), roots)
+    metrics_path = out / "metrics.json"
+    metrics_path.write_text(
+        json.dumps(portable_result, indent=2),
+        encoding="utf-8",
+    )
+
+    from ca.pr_comment import build_pr_comment  # local import avoids cold CLI cycles
+    from ca.report import save_run_report
+
+    summary_path = out / "summary.md"
+    summary_path.write_text(build_pr_comment(portable_result), encoding="utf-8")
+
+    report_path = out / "report.html"
+    save_run_report(portable_result, str(report_path))
+    report_assets = sorted(
+        path.name
+        for path in out.iterdir()
+        if path.is_file()
+        and path.name
+        not in {
+            "manifest.lock.yaml",
+            "metrics.json",
+            "provenance.json",
+            "report.html",
+            "summary.md",
+        }
+    )
+
+    lock_payload = _bundle_lock_payload(
+        suite=suite,
+        sequence=seq,
+        result=portable_result,
+        output_dir=out.resolve(),
+        map_path=map_path,
+        trajectory_path=trajectory_path,
+        report_assets=report_assets,
+        roots=roots,
+    )
+    manifest_lock_path = out / "manifest.lock.yaml"
+    manifest_lock_path.write_text(
+        yaml.safe_dump(lock_payload, sort_keys=False),
+        encoding="utf-8",
+    )
+
+    provenance = {
+        "schema_version": REPORT_BUNDLE_SCHEMA_VERSION,
+        "metrics_schema_version": METRICS_SCHEMA_VERSION,
+        "cloudanalyzer_version": getattr(ca, "__version__", "0.0.0"),
+        "summary_kind": "benchmark_run",
+        "benchmark": portable_result.get("benchmark"),
+        "overall_quality_gate": portable_result.get("overall_quality_gate"),
+        "artifacts": lock_payload["outputs"],
+        "inputs": lock_payload["inputs"],
+    }
+    provenance_path = out / "provenance.json"
+    provenance_path.write_text(
+        json.dumps(provenance, indent=2),
+        encoding="utf-8",
+    )
+
+    return {
+        "bundle_dir": str(out),
+        "metrics": str(metrics_path),
+        "summary": str(summary_path),
+        "report": str(report_path),
+        "manifest_lock": str(manifest_lock_path),
+        "provenance": str(provenance_path),
+    }
+
+
+def validate_benchmark_report_bundle(output_dir: str | Path) -> dict[str, Any]:
+    """Validate the local shape of a benchmark report bundle.
+
+    This checks the machine-readable schema/version and referenced report
+    assets. It deliberately does not resolve portable input paths outside the
+    bundle; input hashes remain the authoritative provenance for that step.
+    """
+    root = Path(output_dir)
+    required = {
+        "metrics": root / "metrics.json",
+        "summary": root / "summary.md",
+        "report": root / "report.html",
+        "manifest_lock": root / "manifest.lock.yaml",
+        "provenance": root / "provenance.json",
+    }
+    missing = [name for name, path in required.items() if not path.is_file()]
+    if missing:
+        raise ValueError(f"Benchmark report bundle is missing: {', '.join(missing)}")
+
+    metrics = json.loads(required["metrics"].read_text(encoding="utf-8"))
+    provenance = json.loads(required["provenance"].read_text(encoding="utf-8"))
+    lock = yaml.safe_load(required["manifest_lock"].read_text(encoding="utf-8"))
+    if metrics.get("schema_version") != METRICS_SCHEMA_VERSION:
+        raise ValueError("metrics.json has an unsupported schema_version")
+    if provenance.get("metrics_schema_version") != METRICS_SCHEMA_VERSION:
+        raise ValueError("provenance.json has an unsupported metrics_schema_version")
+    if lock.get("schema_version") != REPORT_BUNDLE_SCHEMA_VERSION:
+        raise ValueError("manifest.lock.yaml has an unsupported schema_version")
+
+    report_assets = lock.get("outputs", {}).get("report_assets", [])
+    missing_assets = [name for name in report_assets if not (root / name).is_file()]
+    if missing_assets:
+        raise ValueError(
+            "Benchmark report bundle is missing report assets: "
+            + ", ".join(missing_assets)
+        )
+    return {
+        "valid": True,
+        "schema_version": REPORT_BUNDLE_SCHEMA_VERSION,
+        "metrics_schema_version": METRICS_SCHEMA_VERSION,
+        "report_assets": list(report_assets),
+    }
+
+
 # ----------------------------------------------------------- materialize
 
 
@@ -425,7 +683,11 @@ __all__: list[str] = [
     "BenchmarkSequence",
     "BenchmarkSuite",
     "GATE_KEYS",
+    "METRICS_SCHEMA_VERSION",
+    "REPORT_BUNDLE_SCHEMA_VERSION",
     "evaluate_benchmark_run",
     "load_benchmark_suite",
     "materialize_suite",
+    "write_benchmark_report_bundle",
+    "validate_benchmark_report_bundle",
 ]

{cloudanalyzer-0.4.0 → cloudanalyzer-0.5.0}/ca/core/__init__.py

@@ -33,6 +33,13 @@ from ca.core.check_triage import (
     rank_failed_checks,
     summarize_failed_checks,
 )
+from ca.core.gate import (
+    GATE_SEVERITIES,
+    GATE_SUMMARY_SCHEMA_VERSION,
+    gate_status_for_check,
+    normalize_gate_severity,
+    summarize_gate_policy,
+)
 from ca.core.ground_evaluate import (
     GroundEvaluateRequest,
     GroundEvaluateResult,
@@ -90,6 +97,8 @@ __all__ = [
     "GroundEvaluateRequest",
     "GroundEvaluateResult",
     "GroundEvaluateStrategy",
+    "GATE_SEVERITIES",
+    "GATE_SUMMARY_SCHEMA_VERSION",
     "DistanceShellsWebProgressiveLoadingStrategy",
     "RandomBudgetWebSamplingStrategy",
     "RankedCheckTriageItem",
@@ -114,7 +123,9 @@ __all__ = [
     "decide_baseline_evolution",
     "evaluate_ground",
     "failed_dimensions",
+    "gate_status_for_check",
     "load_check_suite",
+    "normalize_gate_severity",
     "normalized_dimension_gaps",
     "plan_progressive_loading_for_web",
     "rank_failed_checks",
@@ -126,4 +137,5 @@ __all__ = [
     "snapshot_margin_stats",
     "summarize_baseline_evolution",
     "summarize_failed_checks",
+    "summarize_gate_policy",
 ]