updates

.devcontainer/devcontainer.json

@@ -1,33 +0,0 @@
-{
-  "name": "Python 3",
-  // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
-  "image": "mcr.microsoft.com/devcontainers/python:1-3.11-bullseye",
-  "customizations": {
-    "codespaces": {
-      "openFiles": [
-        "README.md",
-        "app.py"
-      ]
-    },
-    "vscode": {
-      "settings": {},
-      "extensions": [
-        "ms-python.python",
-        "ms-python.vscode-pylance"
-      ]
-    }
-  },
-  "updateContentCommand": "[ -f packages.txt ] && sudo apt update && sudo apt upgrade -y && sudo xargs apt install -y <packages.txt; [ -f requirements.txt ] && pip3 install --user -r requirements.txt; pip3 install --user streamlit; echo '✅ Packages installed and Requirements met'",
-  "postAttachCommand": {
-    "server": "streamlit run app.py --server.enableCORS false --server.enableXsrfProtection false"
-  },
-  "portsAttributes": {
-    "8501": {
-      "label": "Application",
-      "onAutoForward": "openPreview"
-    }
-  },
-  "forwardPorts": [
-    8501
-  ]
-}

app.py

@@ -9,8 +9,6 @@ from PIL import Image
 import matplotlib.pyplot as plt
 import numpy as np
 import plotly.graph_objects as go
-from helpers import *
-
 
 st.set_page_config(page_title="3D Reconstruction Web App", layout="wide")
 st.markdown("<div style='text-align: center;'><h1>3D Scene Reconstruction</h1></div>", unsafe_allow_html=True)
@@ -129,29 +127,33 @@ def show_ply_interactive(ply_path):
     return fig
 
 # Show PLY as image
-def show_ply_as_image(ply_path):
-    # Load point cloud
-    pcd = o3d.io.read_point_cloud(ply_path)
-
-    # Create visualization window (offscreen)
-    vis = o3d.visualization.Visualizer()
-    vis.create_window(visible=False)
-    vis.add_geometry(pcd)
-
-    # Set camera view
-    ctr = vis.get_view_control()
-    ctr.set_zoom(0.7)
-
-    vis.poll_events()
-    vis.update_renderer()
-
-    # Screenshot to numpy
-    image = vis.capture_screen_float_buffer(do_render=True)
-    vis.destroy_window()
-
-    # Convert to displayable image
-    img = (np.asarray(image) * 255).astype(np.uint8)
-    return Image.fromarray(img)
+# def show_ply_as_image(ply_path):
+#     # Load point cloud
+#     pcd = o3d.io.read_point_cloud(ply_path)
+#     if pcd.is_empty():
+#         raise ValueError("The .ply file is empty or could not be loaded.")
+
+#     # Create visualization window (offscreen)
+#     vis = o3d.visualization.Visualizer()
+#     vis.create_window(visible=False)
+#     vis.add_geometry(pcd)
+
+#     # Set camera view
+#     ctr = vis.get_view_control()
+#     if ctr is None:
+#         raise RuntimeError("Failed to get view control from the visualizer.")
+#     ctr.set_zoom(0.7)
+
+#     vis.poll_events()
+#     vis.update_renderer()
+
+#     # Screenshot to numpy
+#     image = vis.capture_screen_float_buffer(do_render=True)
+#     vis.destroy_window()
+
+#     # Convert to displayable image
+#     img = (np.asarray(image) * 255).astype(np.uint8)
+#     return Image.fromarray(img)
 
 # ---------- Function to extract zip ----------
 def extract_zip(zip_file, extract_to):
@@ -221,7 +223,7 @@ if sfm_zip_file is not None:
     st.success(f"Extracted {zip_name} dataset.")
 
     if st.button("Run SfM Model"):
-        output = run_sfm(sfm_extract_path + "\\" + zip_name)
+        output = run_sfm(os.path.join(sfm_extract_path,zip_name))
         st.success("Model ran successfully.")
 
         # Construct PLY path based on zip filename
@@ -229,8 +231,8 @@ if sfm_zip_file is not None:
 
         if os.path.exists(ply_path):
             st.markdown("### 🧩 Reconstructed Point Cloud Image")
-            image = show_ply_as_image(ply_path)
-            st.image(image, caption=f"{zip_name}.ply", use_column_width=True)
+            # image = show_ply_as_image(ply_path)
+            # st.image(image, caption=f"{zip_name}.ply", use_column_width=True)
 
             # Optional download
             with open(ply_path, "rb") as f:
@@ -251,6 +253,7 @@ if sfm_zip_file is not None:
 
 
 
+
 st.header("🧠 Pix2Vox")
 
 uploaded_images = st.file_uploader(f"Upload images", accept_multiple_files=True, type=["png", "jpg", "jpeg"])

ply_run.py

@@ -1,29 +1,29 @@
-import open3d as o3d
-from PIL import Image
-import matplotlib.pyplot as plt
-import numpy as np
-
-# Show PLY as image
-def show_ply_as_image(ply_path):
-    # Load point cloud
-    pcd = o3d.io.read_point_cloud(ply_path)
-
-    # Create visualization window (offscreen)
-    vis = o3d.visualization.Visualizer()
-    vis.create_window(visible=False)
-    vis.add_geometry(pcd)
-
-    # Set camera view
-    ctr = vis.get_view_control()
-    ctr.set_zoom(0.7)
-
-    vis.poll_events()
-    vis.update_renderer()
-
-    # Screenshot to numpy
-    image = vis.capture_screen_float_buffer(do_render=True)
-    vis.destroy_window()
-
-    # Convert to displayable image
-    img = (np.asarray(image) * 255).astype(np.uint8)
-    return Image.fromarray(img)
+import open3d as o3d
+from PIL import Image
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Show PLY as image
+def show_ply_as_image(ply_path):
+    # Load point cloud
+    pcd = o3d.io.read_point_cloud(ply_path)
+
+    # Create visualization window (offscreen)
+    vis = o3d.visualization.Visualizer()
+    vis.create_window(visible=False)
+    vis.add_geometry(pcd)
+
+    # Set camera view
+    ctr = vis.get_view_control()
+    ctr.set_zoom(0.7)
+
+    vis.poll_events()
+    vis.update_renderer()
+
+    # Screenshot to numpy
+    image = vis.capture_screen_float_buffer(do_render=True)
+    vis.destroy_window()
+
+    # Convert to displayable image
+    img = (np.asarray(image) * 255).astype(np.uint8)
+    return Image.fromarray(img)

requirements.txt

@@ -48,6 +48,11 @@ Werkzeug==3.0.6
 widgetsnbextension==4.0.14
 zipp==3.21.0
 vtk
+opencv-python-headless
+opencv-contrib-python
+streamlit
+matplotlib
+open3d
 opencv-python
 opencv-contrib-python
 streamlit
@@ -57,4 +62,3 @@ argparse
 easydict
 torch
 torchvision
-

sfm.py

@@ -9,13 +9,13 @@ import matplotlib.pyplot as plt
 class Image_loader():
     def __init__(self, img_dir:str, downscale_factor:float):
         # loading the Camera intrinsic parameters K
-        with open(img_dir + '\\K.txt') as f:
+        with open(os.path.join(img_dir,'K.txt')) as f:
             self.K = np.array(list((map(lambda x:list(map(lambda x:float(x), x.strip().split(' '))),f.read().split('\n')))))
             self.image_list = []
         # Loading the set of images
         for image in sorted(os.listdir(img_dir)):
             if image[-4:].lower() == '.jpg' or image[-5:].lower() == '.png':
-                self.image_list.append(img_dir + '\\' + image)
+                self.image_list.append(os.path.join(img_dir,image))
         
         self.path = os.getcwd()
         self.factor = downscale_factor
@@ -143,7 +143,16 @@ class Sfm():
             property uchar red
             end_header
             '''
-        with open(path + '\\res\\' + self.img_obj.image_list[0].split('\\')[-2] + '.ply', 'w') as f:
+        # Ensure the 'res' directory exists
+        res_dir = os.path.join(path, 'res')
+        os.makedirs(res_dir, exist_ok=True)
+    
+        # Use os.path.basename to extract the folder name in a platform-independent way
+        folder_name = os.path.basename(os.path.dirname(self.img_obj.image_list[0]))
+        ply_file_path = os.path.join(res_dir, folder_name + '.ply')
+    
+        # Write the .ply file
+        with open(ply_file_path, 'w') as f:
             f.write(ply_header % dict(vert_num=len(verts)))
             np.savetxt(f, verts, '%f %f %f %d %d %d')
 
@@ -194,7 +203,7 @@ class Sfm():
         return np.float32([key_points_0[m.queryIdx].pt for m in feature]), np.float32([key_points_1[m.trainIdx].pt for m in feature])
 
     def __call__(self, enable_bundle_adjustment:boolean=False):
-        cv2.namedWindow('image', cv2.WINDOW_NORMAL)
+        # cv2.namedWindow('image', cv2.WINDOW_NORMAL)
         pose_array = self.img_obj.K.ravel()
         transform_matrix_0 = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0]])
         transform_matrix_1 = np.empty((3, 4))
@@ -279,24 +288,28 @@ class Sfm():
 
             transform_matrix_0 = np.copy(transform_matrix_1)
             pose_0 = np.copy(pose_1)
-            plt.scatter(i, error)
-            plt.pause(0.05)
+            # plt.scatter(i, error)
+            # plt.pause(0.05)
 
             image_0 = np.copy(image_1)
             image_1 = np.copy(image_2)
             feature_0 = np.copy(features_cur)
             feature_1 = np.copy(features_2)
             pose_1 = np.copy(pose_2)
-            cv2.imshow(self.img_obj.image_list[0].split('\\')[-2], image_2)
-            if cv2.waitKey(1) & 0xff == ord('q'):
-                break
-        cv2.destroyAllWindows()
+            # # cv2.imshow(self.img_obj.image_list[0].split('\\')[-2], image_2)
+            # if cv2.waitKey(1) & 0xff == ord('q'):
+            #     break
+        # cv2.destroyAllWindows()
 
         print("Printing to .ply file")
         print(total_points.shape, total_colors.shape)
         self.to_ply(self.img_obj.path, total_points, total_colors)
         print("Completed Exiting ...")
-        np.savetxt(self.img_obj.path + '\\res\\' + self.img_obj.image_list[0].split('\\')[-2]+'_pose_array.csv', pose_array, delimiter = '\n')
+        output_dir = os.path.join(self.img_obj.path, 'res')
+        os.makedirs(output_dir, exist_ok=True)  # Ensure the 'res' directory exists
+        folder_name = os.path.basename(os.path.dirname(self.img_obj.image_list[0]))
+        output_file = os.path.join(output_dir, f"{folder_name}_pose_array.csv")
+        np.savetxt(output_file, pose_array, delimiter='\n')
 
 
 

space_carving.py

@@ -1,111 +1,111 @@
-import scipy.io
-import numpy as np
-import cv2
-import glob
-import matplotlib.pyplot as plt
-import vtk
-
-def run_space_carving():
-    data = scipy.io.loadmat("uploads_spacecarving/data/dino_Ps.mat")["P"]
-    projections = [data[0, i] for i in range(data.shape[1])]
-    
-    # === Load and preprocess images ===
-    files = sorted(glob.glob("uploads_spacecarving/data/*.ppm"))
-    images = []
-    for f in files:
-        im = cv2.imread(f, cv2.IMREAD_UNCHANGED).astype(float)
-        im /= 255
-        images.append(im[:, :, ::-1])  # BGR to RGB
-    
-    # === Create silhouettes ===
-    imgH, imgW, _ = images[0].shape
-    silhouettes = []
-    for im in images:
-        mask = np.abs(im - [0.0, 0.0, 0.75])
-        mask = np.sum(mask, axis=2)
-        y, x = np.where(mask <= 1.1)
-        im[y, x, :] = [0.0, 0.0, 0.0]
-        im = im[:, :, 0]
-        im[im > 0] = 1.0
-        im = im.astype(np.uint8)
-        kernel = np.ones((5, 5), np.uint8)
-        im = cv2.morphologyEx(im, cv2.MORPH_OPEN, kernel)
-        silhouettes.append(im)
-    
-    # === Create voxel grid ===
-    s = 120
-    x, y, z = np.mgrid[:s, :s, :s]
-    pts = np.vstack((x.flatten(), y.flatten(), z.flatten())).astype(float).T
-    nb_points_init = pts.shape[0]
-    
-    # Normalize and center
-    pts[:, 0] /= np.max(pts[:, 0])
-    pts[:, 1] /= np.max(pts[:, 1])
-    pts[:, 2] /= np.max(pts[:, 2])
-    center = np.mean(pts, axis=0)
-    pts -= center
-    pts /= 5
-    pts[:, 2] -= 0.62
-    
-    # Homogeneous coordinates
-    pts_hom = np.vstack((pts.T, np.ones((1, nb_points_init))))
-    
-    # === Voxel carving: count silhouettes where voxel is occupied ===
-    filled = []
-    for P, sil in zip(projections, silhouettes):
-        uvs = P @ pts_hom
-        uvs /= uvs[2, :]
-        uvs = np.round(uvs).astype(int)
-        x_valid = np.logical_and(uvs[0, :] >= 0, uvs[0, :] < imgW)
-        y_valid = np.logical_and(uvs[1, :] >= 0, uvs[1, :] < imgH)
-        valid = np.logical_and(x_valid, y_valid)
-        indices = np.where(valid)[0]
-        fill = np.zeros(uvs.shape[1])
-        sub_uvs = uvs[:2, indices]
-        res = sil[sub_uvs[1, :], sub_uvs[0, :]]
-        fill[indices] = res
-        filled.append(fill)
-    
-    filled = np.vstack(filled)
-    occupancy = np.sum(filled, axis=0)
-    
-    # === Save voxel grid as .vtr (only the voxels with occupancy > threshold) ===
-    threshold = 25
-    occupancy_mask = (occupancy > threshold).astype(np.float32)
-    
-    # Create grid coordinates
-    x_coords = sorted(list(set(np.round(pts[:, 0][::s*s], 6))))
-    y_coords = sorted(list(set(np.round(pts[:, 1][:s*s:s], 6))))
-    z_coords = sorted(list(set(np.round(pts[:, 2][:s], 6))))
-    
-    x_array = vtk.vtkFloatArray()
-    y_array = vtk.vtkFloatArray()
-    z_array = vtk.vtkFloatArray()
-    
-    for val in x_coords:
-        x_array.InsertNextValue(val)
-    for val in y_coords:
-        y_array.InsertNextValue(val)
-    for val in z_coords:
-        z_array.InsertNextValue(val)
-    
-    # Only add occupancy values for retained voxels
-    values = vtk.vtkFloatArray()
-    values.SetName("Occupancy")
-    for i in range(len(occupancy_mask)):
-        values.InsertNextValue(occupancy_mask[i])
-    
-    # Create rectilinear grid
-    rgrid = vtk.vtkRectilinearGrid()
-    rgrid.SetDimensions(len(x_coords), len(y_coords), len(z_coords))
-    rgrid.SetXCoordinates(x_array)
-    rgrid.SetYCoordinates(y_array)
-    rgrid.SetZCoordinates(z_array)
-    rgrid.GetPointData().SetScalars(values)
-    
-    # Save to .vtr
-    writer = vtk.vtkXMLRectilinearGridWriter()
-    writer.SetFileName("res_space/shape.vtr")
-    writer.SetInputData(rgrid)
-    writer.Write()
+import scipy.io
+import numpy as np
+import cv2
+import glob
+import matplotlib.pyplot as plt
+import vtk
+
+def run_space_carving():
+    data = scipy.io.loadmat("uploads_spacecarving/data/dino_Ps.mat")["P"]
+    projections = [data[0, i] for i in range(data.shape[1])]
+    
+    # === Load and preprocess images ===
+    files = sorted(glob.glob("uploads_spacecarving/data/*.ppm"))
+    images = []
+    for f in files:
+        im = cv2.imread(f, cv2.IMREAD_UNCHANGED).astype(float)
+        im /= 255
+        images.append(im[:, :, ::-1])  # BGR to RGB
+    
+    # === Create silhouettes ===
+    imgH, imgW, _ = images[0].shape
+    silhouettes = []
+    for im in images:
+        mask = np.abs(im - [0.0, 0.0, 0.75])
+        mask = np.sum(mask, axis=2)
+        y, x = np.where(mask <= 1.1)
+        im[y, x, :] = [0.0, 0.0, 0.0]
+        im = im[:, :, 0]
+        im[im > 0] = 1.0
+        im = im.astype(np.uint8)
+        kernel = np.ones((5, 5), np.uint8)
+        im = cv2.morphologyEx(im, cv2.MORPH_OPEN, kernel)
+        silhouettes.append(im)
+    
+    # === Create voxel grid ===
+    s = 120
+    x, y, z = np.mgrid[:s, :s, :s]
+    pts = np.vstack((x.flatten(), y.flatten(), z.flatten())).astype(float).T
+    nb_points_init = pts.shape[0]
+    
+    # Normalize and center
+    pts[:, 0] /= np.max(pts[:, 0])
+    pts[:, 1] /= np.max(pts[:, 1])
+    pts[:, 2] /= np.max(pts[:, 2])
+    center = np.mean(pts, axis=0)
+    pts -= center
+    pts /= 5
+    pts[:, 2] -= 0.62
+    
+    # Homogeneous coordinates
+    pts_hom = np.vstack((pts.T, np.ones((1, nb_points_init))))
+    
+    # === Voxel carving: count silhouettes where voxel is occupied ===
+    filled = []
+    for P, sil in zip(projections, silhouettes):
+        uvs = P @ pts_hom
+        uvs /= uvs[2, :]
+        uvs = np.round(uvs).astype(int)
+        x_valid = np.logical_and(uvs[0, :] >= 0, uvs[0, :] < imgW)
+        y_valid = np.logical_and(uvs[1, :] >= 0, uvs[1, :] < imgH)
+        valid = np.logical_and(x_valid, y_valid)
+        indices = np.where(valid)[0]
+        fill = np.zeros(uvs.shape[1])
+        sub_uvs = uvs[:2, indices]
+        res = sil[sub_uvs[1, :], sub_uvs[0, :]]
+        fill[indices] = res
+        filled.append(fill)
+    
+    filled = np.vstack(filled)
+    occupancy = np.sum(filled, axis=0)
+    
+    # === Save voxel grid as .vtr (only the voxels with occupancy > threshold) ===
+    threshold = 25
+    occupancy_mask = (occupancy > threshold).astype(np.float32)
+    
+    # Create grid coordinates
+    x_coords = sorted(list(set(np.round(pts[:, 0][::s*s], 6))))
+    y_coords = sorted(list(set(np.round(pts[:, 1][:s*s:s], 6))))
+    z_coords = sorted(list(set(np.round(pts[:, 2][:s], 6))))
+    
+    x_array = vtk.vtkFloatArray()
+    y_array = vtk.vtkFloatArray()
+    z_array = vtk.vtkFloatArray()
+    
+    for val in x_coords:
+        x_array.InsertNextValue(val)
+    for val in y_coords:
+        y_array.InsertNextValue(val)
+    for val in z_coords:
+        z_array.InsertNextValue(val)
+    
+    # Only add occupancy values for retained voxels
+    values = vtk.vtkFloatArray()
+    values.SetName("Occupancy")
+    for i in range(len(occupancy_mask)):
+        values.InsertNextValue(occupancy_mask[i])
+    
+    # Create rectilinear grid
+    rgrid = vtk.vtkRectilinearGrid()
+    rgrid.SetDimensions(len(x_coords), len(y_coords), len(z_coords))
+    rgrid.SetXCoordinates(x_array)
+    rgrid.SetYCoordinates(y_array)
+    rgrid.SetZCoordinates(z_array)
+    rgrid.GetPointData().SetScalars(values)
+    
+    # Save to .vtr
+    writer = vtk.vtkXMLRectilinearGridWriter()
+    writer.SetFileName("res_space/shape.vtr")
+    writer.SetInputData(rgrid)
+    writer.Write()