Upload rewrite_op.py

rewrite_op.py

@@ -0,0 +1,205 @@
+"""
+Rewrite a 3DGS PLY opacity field to a saturated infer-like distribution.
+
+The PLY `opacity` field in standard 3DGS is raw logit opacity, not alpha.
+This script builds a target alpha distribution and writes logit(alpha) back
+to the PLY while leaving all other vertex fields unchanged.
+
+Default profile:
+  - 95% of points get alpha=0.95, matching an opacity cap at logit(0.95)
+  - the remaining 5% get a tiny transparent tail near the user's diagnose log
+"""
+
+import argparse
+import os
+
+import numpy as np
+
+
+PERCENTILES = [0, 1, 50, 90, 95, 99, 99.9, 100]
+DEFAULT_LOW_ALPHA_MIN = 1.2487531e-6
+DEFAULT_LOW_ALPHA_MAX = 5.3099717e-6
+
+
+def sigmoid(x: np.ndarray) -> np.ndarray:
+    return 1.0 / (1.0 + np.exp(-np.clip(x, -80.0, 80.0)))
+
+
+def logit(alpha: np.ndarray) -> np.ndarray:
+    alpha = np.clip(alpha, 1e-6, 1.0 - 1e-6)
+    return np.log(alpha / (1.0 - alpha))
+
+
+def print_percentiles(name: str, values: np.ndarray) -> None:
+    pct = np.percentile(values, PERCENTILES, axis=0)
+    print(f"\n[{name}]")
+    for p, row in zip(PERCENTILES, pct):
+        row = np.asarray(row).reshape(-1)
+        joined = "  ".join(f"{float(v): .8g}" for v in row)
+        print(f"  p{p:>5}: {joined}")
+
+
+def build_alpha_profile(
+    n_points: int,
+    high_fraction: float,
+    high_alpha: float,
+    low_alpha_min: float,
+    low_alpha_max: float,
+    seed: int,
+) -> np.ndarray:
+    if n_points <= 0:
+        return np.zeros((0,), dtype=np.float32)
+
+    high_fraction = float(np.clip(high_fraction, 0.0, 1.0))
+    high_alpha = float(np.clip(high_alpha, 1e-6, 1.0 - 1e-6))
+    low_alpha_min = float(np.clip(low_alpha_min, 1e-6, 1.0 - 1e-6))
+    low_alpha_max = float(np.clip(low_alpha_max, low_alpha_min, high_alpha))
+
+    n_high = int(round(n_points * high_fraction))
+    n_high = max(0, min(n_points, n_high))
+    n_low = n_points - n_high
+
+    alpha = np.empty(n_points, dtype=np.float32)
+    if n_low > 0:
+        # Log-space tail keeps the low-opacity values close to the diagnose log.
+        low = np.geomspace(low_alpha_min, low_alpha_max, n_low).astype(np.float32)
+        alpha[:n_low] = low
+    if n_high > 0:
+        alpha[n_low:] = high_alpha
+
+    rng = np.random.default_rng(seed)
+    rng.shuffle(alpha)
+    return alpha
+
+
+def assign_alpha(
+    original_raw_opacity: np.ndarray,
+    target_alpha: np.ndarray,
+    assignment: str,
+    seed: int,
+) -> np.ndarray:
+    if assignment == "random":
+        return target_alpha
+
+    if assignment == "rank":
+        original_alpha = sigmoid(original_raw_opacity)
+        order_src = np.argsort(original_alpha)
+        sorted_target = np.sort(target_alpha)
+        assigned = np.empty_like(target_alpha)
+        assigned[order_src] = sorted_target
+        return assigned
+
+    if assignment == "shuffle":
+        assigned = np.sort(target_alpha)
+        rng = np.random.default_rng(seed)
+        rng.shuffle(assigned)
+        return assigned
+
+    raise ValueError(f"Unknown assignment mode: {assignment}")
+
+
+def rewrite_opacity(args: argparse.Namespace) -> None:
+    try:
+        from plyfile import PlyData, PlyElement
+    except ImportError as exc:
+        raise ImportError(
+            "Missing dependency 'plyfile'. Install it in the environment that will run this "
+            "script, for example: pip install plyfile"
+        ) from exc
+
+    ply = PlyData.read(args.input_ply)
+    if "vertex" not in ply:
+        raise ValueError("PLY does not contain a vertex element")
+
+    vertex = ply["vertex"]
+    names = vertex.data.dtype.names
+    if "opacity" not in names:
+        raise ValueError("PLY vertex element does not contain an opacity field")
+
+    arr = vertex.data.copy()
+    original_raw = np.asarray(arr["opacity"], dtype=np.float32).reshape(-1)
+
+    target_alpha = build_alpha_profile(
+        n_points=original_raw.shape[0],
+        high_fraction=args.high_fraction,
+        high_alpha=args.high_alpha,
+        low_alpha_min=args.low_alpha_min,
+        low_alpha_max=args.low_alpha_max,
+        seed=args.seed,
+    )
+    assigned_alpha = assign_alpha(
+        original_raw_opacity=original_raw,
+        target_alpha=target_alpha,
+        assignment=args.assignment,
+        seed=args.seed,
+    )
+    new_raw = logit(assigned_alpha).astype(np.float32)
+    arr["opacity"] = new_raw
+
+    os.makedirs(os.path.dirname(os.path.abspath(args.output_ply)), exist_ok=True)
+    PlyData([PlyElement.describe(arr, "vertex")], text=ply.text).write(args.output_ply)
+
+    print(f"[rewrite] input:  {os.path.abspath(args.input_ply)}")
+    print(f"[rewrite] output: {os.path.abspath(args.output_ply)}")
+    print(f"[rewrite] points: {original_raw.shape[0]:,}")
+    print(
+        "[rewrite] target profile: "
+        f"high_fraction={args.high_fraction:.4f}, high_alpha={args.high_alpha:.6f}, "
+        f"low_alpha=[{args.low_alpha_min:.8g}, {args.low_alpha_max:.8g}], "
+        f"assignment={args.assignment}"
+    )
+
+    print_percentiles("original opacity raw field", original_raw)
+    print_percentiles("original sigmoid(opacity)", sigmoid(original_raw))
+    print_percentiles("written opacity raw field", new_raw)
+    print_percentiles("written sigmoid(opacity)", sigmoid(new_raw))
+
+    high_hit = np.mean(assigned_alpha >= args.high_alpha - 1e-6)
+    print(f"\n[summary] fraction(alpha >= high_alpha): {high_hit:.4%}")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Rewrite a 3DGS PLY opacity field to an infer-like saturated alpha distribution."
+    )
+    parser.add_argument("input_ply", help="Input PLY path.")
+    parser.add_argument("output_ply", help="Output PLY path.")
+    parser.add_argument(
+        "--high_fraction",
+        type=float,
+        default=0.95,
+        help="Fraction of points assigned high_alpha. Default: 0.95.",
+    )
+    parser.add_argument(
+        "--high_alpha",
+        type=float,
+        default=0.95,
+        help="High target alpha value. Written as logit(high_alpha). Default: 0.95.",
+    )
+    parser.add_argument(
+        "--low_alpha_min",
+        type=float,
+        default=DEFAULT_LOW_ALPHA_MIN,
+        help="Minimum alpha for the transparent tail.",
+    )
+    parser.add_argument(
+        "--low_alpha_max",
+        type=float,
+        default=DEFAULT_LOW_ALPHA_MAX,
+        help="Maximum alpha for the transparent tail.",
+    )
+    parser.add_argument(
+        "--assignment",
+        choices=["rank", "random", "shuffle"],
+        default="rank",
+        help=(
+            "How to assign target alphas to points. 'rank' preserves the original opacity rank; "
+            "'random' uses the generated shuffled profile; 'shuffle' shuffles a sorted profile."
+        ),
+    )
+    parser.add_argument("--seed", type=int, default=42, help="Random seed for tail shuffling.")
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    rewrite_opacity(parse_args())