Initial release: PlyPreview nodes and viewer

Author: XuanYu-github

LICENSE

@@ -0,0 +1,8 @@
+GNU GENERAL PUBLIC LICENSE
+Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+[Full GPLv3 text omitted for brevity. Obtain the complete license at https://www.gnu.org/licenses/gpl-3.0.txt]

README.md

@@ -0,0 +1,43 @@
+# ComfyUI PlyPreview
+
+Gaussian Splat PLY loader + preview nodes for ComfyUI. Forked from GeometryPack and repackaged to avoid upstream overwrites. Includes front-end viewer (gsplat.js) bundled locally.
+
+## Nodes
+- Load Gaussian PLY — dropdown from `input/`, `input/3d`, `output/` with auto-resolution, FOV 10–180°, optional opacity filter.
+- Load Gaussian PLY (Path) — manual path entry with the same camera/auto-res options.
+- Process Gaussian PLY — accept upstream `ply_path` (e.g., SHARP Predict) with camera override/opacity filter.
+- Preview Gaussian — gsplat.js WebGL viewer with scale slider, reset, screenshot, info panel.
+
+## Features
+- Auto resolution from FOV + target scale (rounded to 16px, calibration factor 0.8).
+- Opacity filtering (sigmoid) with threshold.
+- Camera intrinsics/extrinsics outputs for consistent preview.
+- Wide FOV (10–180°) including fisheye cases.
+- Fully self-contained: viewer HTML/JS bundled under `web/`.
+
+## Install (Git clone)
+```bash
+cd ComfyUI/custom_nodes
+git clone https://github.com/XuanYu-github/comfyui-PlyPreview.git
+```
+Restart ComfyUI.
+
+## Install (ComfyUI Manager)
+Search for “comfyui-PlyPreview” in Manager and install. (This repo ships `comfyui_extension.json` so Manager can detect it.)
+
+## Usage
+1) Use one of the Load nodes or Process node to produce `ply_path`, `extrinsics`, `intrinsics`.
+2) Connect to Preview Gaussian. After execution the viewer iframe shows controls (Scale, Reset View, Screenshot) and info panel.
+3) If opacity filtering is enabled, a filtered PLY is written alongside the source (suffix `_opacity{threshold}.ply`).
+
+## Requirements
+- ComfyUI recent build with DOM widgets enabled (standard).
+- Python deps: `plyfile`, `numpy` (install via your ComfyUI environment). Most ComfyUI setups already have numpy; install plyfile if missing: `pip install plyfile`.
+
+## Notes
+- WEB_DIRECTORY is set to `web` so ComfyUI loads the bundled frontend automatically.
+- Namespaces are prefixed `PlyPreview*` to avoid collision with GeometryPack.
+- Original GeometryPack license is GPL-3.0; this fork keeps the same license.
+
+## License
+GPL-3.0-or-later. See [LICENSE](LICENSE).

__init__.py

@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# Copyright (C) 2025 comfyui-PlyPreview Contributors
+
+"""ComfyUI PLY Preview - Gaussian splat PLY file loading and preview nodes."""
+
+from .load_gaussian_ply import LoadGaussianPLY
+from .load_gaussian_ply_path import LoadGaussianPLYPath
+from .process_gaussian_ply import ProcessGaussianPLY
+from .preview_gaussian import PreviewGaussianNode
+
+WEB_DIRECTORY = "web"
+
+NODE_CLASS_MAPPINGS = {
+    "PlyPreviewLoadGaussianPLY": LoadGaussianPLY,
+    "PlyPreviewLoadGaussianPLYPath": LoadGaussianPLYPath,
+    "PlyPreviewProcessGaussianPLY": ProcessGaussianPLY,
+    "PlyPreviewPreviewGaussian": PreviewGaussianNode,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "PlyPreviewLoadGaussianPLY": "Load Gaussian PLY",
+    "PlyPreviewLoadGaussianPLYPath": "Load Gaussian PLY (Path)",
+    "PlyPreviewProcessGaussianPLY": "Process Gaussian PLY",
+    "PlyPreviewPreviewGaussian": "Preview Gaussian",
+}
+
+__all__ = [
+    "NODE_CLASS_MAPPINGS",
+    "NODE_DISPLAY_NAME_MAPPINGS",
+    "LoadGaussianPLY",
+    "LoadGaussianPLYPath",
+    "ProcessGaussianPLY",
+    "PreviewGaussianNode",
+]

comfyui_extension.json

@@ -0,0 +1,8 @@
+{
+  "name": "comfyui-PlyPreview",
+  "display_name": "PlyPreview",
+  "description": "Gaussian Splat PLY loader + preview nodes (Load, Load Path, Process, Preview) with bundled gsplat viewer.",
+  "author": "XuanYu-github",
+  "repo": "https://github.com/XuanYu-github/comfyui-PlyPreview",
+  "license": "GPL-3.0-or-later"
+}

common.py

@@ -0,0 +1,82 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import os
+
+# Optional ComfyUI helpers – avoid hard dependency for offline editing
+try:
+    import importlib
+    folder_paths = importlib.import_module("folder_paths")  # type: ignore[import-not-found]
+    COMFYUI_INPUT_FOLDER: str | None = folder_paths.get_input_directory()
+    COMFYUI_OUTPUT_FOLDER: str | None = folder_paths.get_output_directory()
+except Exception:  # pragma: no cover - environment-specific
+    folder_paths = None  # type: ignore[assignment]
+    COMFYUI_INPUT_FOLDER = None
+    COMFYUI_OUTPUT_FOLDER = None
+
+
+def get_default_extrinsics() -> list[list[float]]:
+    """Return default 4x4 identity extrinsics matrix (camera at origin)."""
+    return [
+        [1.0, 0.0, 0.0, 0.0],
+        [0.0, 1.0, 0.0, 0.0],
+        [0.0, 0.0, 1.0, 0.0],
+        [0.0, 0.0, 0.0, 1.0],
+    ]
+
+
+def get_default_intrinsics(width: int = 512, height: int = 512, fov_degrees: float = 50.0) -> list[list[float]]:
+    """Return default 3x3 intrinsics matrix from FOV."""
+    import math
+
+    fov_rad = math.radians(fov_degrees)
+    fx = width / (2.0 * math.tan(fov_rad / 2.0))
+    fy = fx  # assume square pixels
+    cx = width / 2.0
+    cy = height / 2.0
+
+    return [
+        [fx, 0.0, cx],
+        [0.0, fy, cy],
+        [0.0, 0.0, 1.0],
+    ]
+
+
+def get_recommended_resolution(fov_degrees: float, target_scale: float = 10.0) -> tuple[int, int]:
+    """Get recommended width/height based on FOV and target gaussian scale."""
+    reference_points = [
+        (10.0, 61440.0),
+        (30.0, 15360.0),
+        (50.0, 10240.0),
+        (100.0, 4096.0),
+        (120.0, 2560.0),
+        (150.0, 1920.0),
+        (180.0, 1600.0),
+    ]
+
+    fov_clamped = max(10.0, min(180.0, fov_degrees))
+
+    product = 0.0
+    if fov_clamped <= reference_points[0][0]:
+        product = reference_points[0][1]
+    elif fov_clamped >= reference_points[-1][0]:
+        product = reference_points[-1][1]
+    else:
+        for i in range(len(reference_points) - 1):
+            fov1, prod1 = reference_points[i]
+            fov2, prod2 = reference_points[i + 1]
+            if fov1 <= fov_clamped <= fov2:
+                t = (fov_clamped - fov1) / (fov2 - fov1)
+                product = prod1 + t * (prod2 - prod1)
+                break
+
+    base_resolution = product / 10.0
+    target_resolution = base_resolution * (10.0 / target_scale)
+
+    calibration_factor = 0.8
+    target_resolution = target_resolution * calibration_factor
+
+    resolution = int(target_resolution + 0.5)
+    resolution = max(256, min(8192, resolution))
+    resolution = ((resolution + 7) // 16) * 16
+
+    return (resolution, resolution)