Update app.py

app.py

@@ -1,17 +1,166 @@
-from fastai.vision.all import *
+import os
+import time
+import random
+import open3d as o3d
+import numpy as np
+from matplotlib import pyplot as plt
+import torch
+
+
+
+
+def as_mesh(points):
+   
+    
+        
+    pcd = o3d.geometry.PointCloud()
+   
+    pcd.points = o3d.utility.Vector3dVector(points[0])
+    pcd.estimate_normals()
+    pcd.orient_normals_consistent_tangent_plane(100)
+    show_mesh((pcd))
+    alpha = 0.04
+    print(f"alpha={alpha:.3f}")
+    mesh = o3d.geometry.TriangleMesh.create_from_point_cloud_alpha_shape(pcd, alpha)
+    mesh.compute_vertex_normals()
+
+    
+    voxel_size = max(mesh.get_max_bound() - mesh.get_min_bound()) / 32
+
+    
+    mesh = mesh.simplify_vertex_clustering(voxel_size=voxel_size,contraction=o3d.geometry.SimplificationContraction.Average)
+    
+    points = np.asarray(mesh.vertices)
+
+
+
+def ddim_step(x_t, noise, abar_t, abar_t1, bbar_t, bbar_t1, eta, sig,m, clamp=True):
+    sig = ((bbar_t1/bbar_t).sqrt() * (1-abar_t/abar_t1).sqrt()) * eta
+    x_0_hat = ((x_t-(1-abar_t).sqrt()*noise) / abar_t.sqrt())
+    if clamp: x_0_hat = x_0_hat.clamp(-1,1)
+    if bbar_t1<=sig**2+0.01: sig=0.  # set to zero if very small or NaN
+    x_t = abar_t1.sqrt()*x_0_hat + (bbar_t1-sig**2).sqrt()*noise 
+    if x_t.isnan().any():
+      
+        x_t = torch.ones(x_t.shape)
+    
+    x__0_hat = x_t*m
+   
+
+    x_t += sig * torch.randn(x_t.shape).to(x_t)
+    
+  
+    return x__0_hat,x_t
+
+
+
+
+
+def cond_sample(c, f, model, sz, steps, eta=1.):
+    ts = torch.linspace(1-1/steps,0,steps)
+    x_t = torch.randn(sz)
+    c = x_t.new_full((sz[0],), c, dtype=torch.int32)
+    preds = []
+    for i,t in enumerate(progress_bar(ts)):
+        t = t[None]
+        abar_t = abar(t)
+        noise = model((x_t, t, c))
+        abar_t1 = abar(t-1/steps) if t>=1/steps else torch.tensor(1)
+        x_0_hat,x_t = f(x_t, noise, abar_t, abar_t1, 1-abar_t, 1-abar_t1, eta, 1-((i+1)/100),m)
+        preds.append(x_0_hat.float().cpu())
+    return preds
+
+
+
+
+def load_mod():
+    model = CondUNetModel(8, in_channels=1, out_channels=1, nfs=(64,128,256,512), num_layers=30, attn_chans = 64)
+    model.load_state_dict(torch.load('working/model.pt'))
+
+    model
+    model.eval()
+
+
+def normalize(v):
+    norm = np.linalg.norm(v)
+    
+    if norm == 0: 
+        return v
+
+    return v / norm
+def diff3D(prompt):
+    
+    base_path = os.path.join(os.getcwd(), '3D-Data')
+    
+
+    if not os.path.exists(os.path.join(base_path, prompt)):
+        return "False Prompt"
+    folder_path = os.path.join(base_path, prompt)
+    
+   
+    
+    models = os.listdir(folder_path)
+    random_model = random.choice(models)
+    model_path = os.path.join(folder_path, random_model)
+    mesh = o3d.io.read_triangle_mesh(model_path)
+    mesh.compute_vertex_normals()
+    pcda = mesh.sample_points_uniformly(number_of_points=512*4)
+    pcda = mesh.sample_points_poisson_disk(number_of_points=256*4, pcl=pcda)
+    points = normalize(np.asarray(pcda.points))
+    
+    
+    pcd = o3d.geometry.PointCloud()
+   
+    pcd.points = o3d.utility.Vector3dVector(points)
+    pcd.estimate_normals()
+    pcd.orient_normals_consistent_tangent_plane(100)
+    alpha = 0.03
+    if prompt == 'Vase' or prompt == 'Table':
+        alpha = 0.015
+    
+    
+    mesh = o3d.geometry.TriangleMesh.create_from_point_cloud_alpha_shape(pcd, alpha)
+    mesh.compute_vertex_normals()
+    
+    
+    voxel_size = max(mesh.get_max_bound() - mesh.get_min_bound()) /64
+    mesh = mesh.simplify_vertex_clustering(voxel_size=voxel_size, contraction=o3d.geometry.SimplificationContraction.Average)
+    mesh = o3d.geometry.TriangleMesh.compute_triangle_normals(mesh)
+
+    output_path = os.path.join(base_path, 'out.stl')
+    o3d.io.write_triangle_mesh(output_path, mesh)
+    points = np.asarray(mesh.vertices)
+
+    
+    
+    return os.path.join(base_path, 'out.stl')
+
+
+
+
+
+
+
+
+
 import gradio as gr
+import os
+
+
+
+
 
-cardetector = load_learner('model.pkl')
-labels = cardetector.dls.vocab
-def predict(img):
-    img = PILImage.create(img)
-    brand, index, probs = cardetector.predict(img)
-    return {labels[i]: float(probs[i]) for i in range(len(labels))}
 gr.Interface(
-    fn = predict, 
-    inputs = gr.inputs.Image(shape = (512,512)), 
-    outputs = gr.outputs.Label(num_top_classes=3),
+    fn=diff3D,
+    inputs=gr.Dropdown(
+            ["Cone","Cube","Cylinder","Pencil","Sphere","Table","Vase"], info="Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed auctor, nisl eget ultricies aliquam, nunc nisl aliquet nunc, eget aliquam nisl nunc vel nisl."
+        )
+    
+    ,
+    outputs=gr.Model3D(
+            clear_color=[0.0, 0.0, 0.0, 0.0],  label="3D Model"),
     title = "Car Detector",
     description = "A classfier to detect car brands from an image. Created using the car connection picture dataset as a demo for hugging face and gradio.",
   
-).launch()
+).launch()
+