initial commit

README.md

@@ -8,7 +8,7 @@ sdk_version: 5.13.1
 app_file: app.py
 pinned: false
 license: mit
-short_description: Convert Gaussian Splats from `.ply` to `.splat` format.
+short_description: Convert gaussian splats from `.ply` to `.splat` format.
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,219 @@
+import math
+import os
+import struct
+
+import gradio as gr
+
+SH_C0 = 0.28209479177387814
+
+def read_ply_header(fileobj, max_lines=50000):
+    header_lines = []
+    for _ in range(max_lines):
+        line_bytes = fileobj.readline()
+        if not line_bytes:
+            raise ValueError("Unexpected EOF while searching for end_header.")
+
+        line_str = line_bytes.decode("ascii", errors="replace")
+        header_lines.append(line_str)
+
+        if "end_header" in line_str:
+            break
+    else:
+        raise ValueError(f"No 'end_header' found in the first {max_lines} header lines")
+
+    return header_lines
+
+def parse_ply_header_lines(header_lines):
+    vertex_count = 0
+    prop_list = []
+    is_binary_le = False
+
+    in_vertex_element = False
+
+    for line in header_lines:
+        line = line.strip()
+
+        if line.startswith("format "):
+            if "binary_little_endian" in line:
+                is_binary_le = True
+            elif "ascii" in line:
+                raise ValueError("ASCII PLY is not supported by this example.")
+            else:
+                raise ValueError("Only binary_little_endian PLY is handled here.")
+
+        elif line.startswith("element vertex"):
+            parts = line.split()
+            vertex_count = int(parts[2])
+            in_vertex_element = True
+
+        elif line.startswith("element ") and not line.startswith("element vertex"):
+            in_vertex_element = False
+
+        elif in_vertex_element and line.startswith("property "):
+            parts = line.split()
+            prop_type = parts[1]
+            prop_name = parts[2]
+            prop_list.append((prop_name, prop_type))
+
+    return vertex_count, prop_list, is_binary_le
+
+def ply_to_splat(ply_path):
+    if not ply_path.endswith(".ply"):
+        raise ValueError("Input file must be a .ply file")
+
+    with open(ply_path, "rb") as f:
+        header_lines = read_ply_header(f)
+
+        vertex_count, properties, is_bin_le = parse_ply_header_lines(header_lines)
+        if not is_bin_le:
+            raise ValueError("PLY is not binary_little_endian; cannot continue.")
+
+        type_map = {
+            "float":  ("f", 4),
+            "float32":("f", 4),
+            "double": ("d", 8),
+            "float64":("d", 8),
+            "int":    ("i", 4),
+            "int32":  ("i", 4),
+            "uint":   ("I", 4),
+            "uint32": ("I", 4),
+            "short":  ("h", 2),
+            "ushort": ("H", 2),
+            "int16":  ("h", 2),
+            "uint16": ("H", 2),
+            "char":   ("b", 1),
+            "uchar":  ("B", 1),
+            "int8":   ("b", 1),
+            "uint8":  ("B", 1),
+        }
+        prop_structs = []
+        row_size = 0
+        for (name, ptype) in properties:
+            if ptype not in type_map:
+                raise ValueError(f"Unsupported property type: {ptype}")
+            fmt, size = type_map[ptype]
+            prop_structs.append((name, fmt, size))
+            row_size += size
+
+        splat_data = bytearray(32 * vertex_count)
+
+        def clamp_byte(x):
+            return max(0, min(255, int(round(x))))
+
+        def write_float(offset, value):
+            struct.pack_into("<f", splat_data, offset, value)
+
+        total_vertex_bytes = row_size * vertex_count
+        vertex_block = f.read(total_vertex_bytes)
+        if len(vertex_block) < total_vertex_bytes:
+            raise ValueError("Not enough data for all vertices in the file.")
+
+        idx = 0
+        for i in range(vertex_count):
+            out_offset = i * 32
+            px, py, pz = 0.0, 0.0, 0.0
+            sx, sy, sz = 1.0, 1.0, 1.0
+            cr, cg, cb, ca = 255, 255, 255, 255
+            rw, rx, ry, rz = 1.0, 0.0, 0.0, 0.0
+
+            prop_offset = 0
+            for (prop_name, prop_fmt, prop_size) in prop_structs:
+                raw_value = struct.unpack_from("<" + prop_fmt, vertex_block, idx + prop_offset)[0]
+                prop_offset += prop_size
+
+                if prop_name == "x":
+                    px = float(raw_value)
+                elif prop_name == "y":
+                    py = float(raw_value)
+                elif prop_name == "z":
+                    pz = float(raw_value)
+
+                elif prop_name in ["red", "r"]:
+                    cr = clamp_byte(raw_value)
+                elif prop_name in ["green", "g"]:
+                    cg = clamp_byte(raw_value)
+                elif prop_name in ["blue", "b"]:
+                    cb = clamp_byte(raw_value)
+                elif prop_name in ["alpha", "a"]:
+                    ca = clamp_byte(raw_value)
+                
+                elif prop_name in ["f_dc_0", "features_0"]:
+                    cr = clamp_byte((0.5 + SH_C0 * raw_value) * 255)
+                elif prop_name in ["f_dc_1", "features_1"]:
+                    cg = clamp_byte((0.5 + SH_C0 * raw_value) * 255)
+                elif prop_name in ["f_dc_2", "features_2"]:
+                    cb = clamp_byte((0.5 + SH_C0 * raw_value) * 255)
+                elif prop_name == "f_dc_3":
+                    ca = clamp_byte((0.5 + SH_C0 * raw_value) * 255)
+
+                elif prop_name in ["scale_0","scaling_0"]:
+                    sx = math.exp(raw_value)
+                elif prop_name in ["scale_1","scaling_1"]:
+                    sy = math.exp(raw_value)
+                elif prop_name in ["scale_2","scaling_2"]:
+                    sz = math.exp(raw_value)
+
+                elif prop_name in ["opacity","opacity_0"]:
+                    val = 1.0 / (1.0 + math.exp(-float(raw_value)))
+                    ca = clamp_byte(val*255.0)
+
+                elif prop_name in ["rot_0","rotation_0"]:
+                    rw = float(raw_value)
+                elif prop_name in ["rot_1","rotation_1"]:
+                    rx = float(raw_value)
+                elif prop_name in ["rot_2","rotation_2"]:
+                    ry = float(raw_value)
+                elif prop_name in ["rot_3","rotation_3"]:
+                    rz = float(raw_value)
+
+            idx += row_size
+
+            length = math.sqrt(rw*rw + rx*rx + ry*ry + rz*rz)
+            if length > 1e-9:
+                rw /= length
+                rx /= length
+                ry /= length
+                rz /= length
+
+            rot0 = clamp_byte(rw * 128 + 128)
+            rot1 = clamp_byte(rx * 128 + 128)
+            rot2 = clamp_byte(ry * 128 + 128)
+            rot3 = clamp_byte(rz * 128 + 128)
+
+            write_float(out_offset + 0, px)
+            write_float(out_offset + 4, py)
+            write_float(out_offset + 8, pz)
+
+            write_float(out_offset + 12, sx)
+            write_float(out_offset + 16, sy)
+            write_float(out_offset + 20, sz)
+
+            splat_data[out_offset + 24] = cr
+            splat_data[out_offset + 25] = cg
+            splat_data[out_offset + 26] = cb
+            splat_data[out_offset + 27] = ca
+
+            splat_data[out_offset + 28] = rot0
+            splat_data[out_offset + 29] = rot1
+            splat_data[out_offset + 30] = rot2
+            splat_data[out_offset + 31] = rot3
+
+    base_dir = os.path.dirname(ply_path)
+    filename = os.path.basename(ply_path)
+    splat_path = os.path.join(base_dir, filename.replace(".ply", ".splat"))
+    with open(splat_path, "wb") as out:
+        out.write(splat_data)
+
+    return splat_path
+
+
+app = gr.Interface(
+    fn=ply_to_splat,
+    title="PLY to SPLAT",
+    description="Convert a .ply gaussian splat file to a .splat file",
+    inputs=gr.Model3D(label="Input .ply file"),
+    outputs=gr.Model3D(label="Output .splat file"),
+)
+
+if __name__ == "__main__":
+    app.launch()