Spaces:
Running
Running
| 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() | |