Create app.py

app.py

@@ -0,0 +1,109 @@
+import laspy
+import numpy as np
+import cv2
+from math import floor, pi
+from multiprocessing import Process, shared_memory, cpu_count
+import gradio as gr
+import time
+
+# ==== Constants ====
+TILE_DIM = 512
+PRECISION = 16
+FACTOR = 2 ** PRECISION
+NUM_WORKERS = cpu_count()
+SHARED_MEMORY_NAME = 'shared_canvas'
+
+# ==== Parameters ====
+IMAGE_HEIGHT = 4096 * 2
+POINT_SIZE = 3
+SCALE_COLORS = False
+FULL_RES = False
+
+def create_shared_memory_array(data, name, dtype):
+    shm = shared_memory.SharedMemory(create=True, size=data.nbytes, name=name)
+    shared_array = np.ndarray(data.shape, dtype=dtype, buffer=shm.buf)
+    shared_array[:] = data
+    return shm
+
+def release_shared_memory(name):
+    shm = shared_memory.SharedMemory(name=name)
+    shm.close()
+    shm.unlink()
+
+def draw_points(start, length, canvas_shape, theta, phi, radius, color):
+    shm = shared_memory.SharedMemory(name=SHARED_MEMORY_NAME)
+    canvas = np.ndarray(canvas_shape, dtype=np.uint16, buffer=shm.buf)
+
+    for i in range(start, start + length):
+        cv2.circle(
+            canvas,
+            (theta[i], phi[i]),
+            radius[i],
+            color=(int(color[i][0]), int(color[i][1]), int(color[i][2])),
+            thickness=cv2.FILLED,
+            shift=PRECISION
+        )
+
+def project_point_cloud(input_file):
+    try:
+        point_cloud = laspy.read(input_file)
+    except FileNotFoundError:
+        return "Input file not found."
+
+    height, width = IMAGE_HEIGHT, IMAGE_HEIGHT * 2
+    output_shape = (height, width, 3)
+    total_points = point_cloud.header.point_count
+
+    background = np.zeros(output_shape, dtype=np.uint16)
+
+    xyz = np.array([point_cloud.x, point_cloud.y, point_cloud.z])
+    distances = np.linalg.norm(xyz, axis=0)
+    distances_norm = (distances - distances.min()) / (distances.max() - distances.min())
+
+    theta = ((width * FACTOR) -
+             (((np.arctan2(point_cloud.y, point_cloud.x) + pi) / (2 * pi)) * width * FACTOR)).astype(np.uint64)
+    phi = ((np.arccos(point_cloud.z / distances) / pi) * height * FACTOR).astype(np.uint64)
+    radii = (FACTOR * POINT_SIZE * (1 - distances_norm) + 1).astype(np.uint64)
+
+    colors = np.stack([point_cloud.blue, point_cloud.green, point_cloud.red], axis=-1).astype(np.uint16)
+    if SCALE_COLORS:
+        colors *= 256
+
+    shm_canvas = create_shared_memory_array(background, SHARED_MEMORY_NAME, np.uint16)
+
+    processes = []
+    num_threads = min(NUM_WORKERS, 4)  # Limit to a reasonable number of threads
+    for i in range(num_threads):
+        start = floor(i * total_points / num_threads)
+        end = floor((i + 1) * total_points / num_threads)
+        p = Process(target=draw_points, args=(start, end - start, output_shape, theta, phi, radii, colors))
+        p.start()
+        processes.append(p)
+
+    for p in processes:
+        p.join()
+
+    final_image = np.ndarray(output_shape, dtype=np.uint16, buffer=shm_canvas.buf)
+    if not FULL_RES:
+        final_image = (final_image / 256).astype(np.uint8)
+
+    output_file = "output_image.jpg"
+    cv2.imwrite(output_file, final_image)
+
+    release_shared_memory(SHARED_MEMORY_NAME)
+    return output_file
+
+# Gradio interface
+def main(input_file):
+    return project_point_cloud(input_file)
+
+iface = gr.Interface(
+    fn=main,
+    inputs=gr.inputs.File(label="Upload LAS File"),
+    outputs=gr.outputs.Image(type="file", label="Output Image"),
+    title="Point Cloud Projection",
+    description="Upload a LAS file to project the point cloud into an image."
+)
+
+if __name__ == "__main__":
+    iface.launch()