""" 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())