fixes

app.py

@@ -119,7 +119,10 @@ def generate_3D(input, model_name='base1B', guidance_scale=3.0, grid_size=128):
     set_state('Converting to mesh...')
 
     uniqid = uuid.uuid4()
-    file_path = f'/tmp/mesh-{uniqid}.ply'
+    file_path = f"/tmp/mesh-{uniqid}.npy"
+
+    print('file_path', file_path)
+
     save_ply(pc, file_path)
 
     set_state('')
@@ -152,8 +155,10 @@ def ply_to_glb(ply_file, glb_file):
 
 def save_ply(pc, file_name):
     # Produce a mesh (with vertex colors)
+    print('file_name', file_name)
     with open(file_name, 'wb') as f:
-        pc.write_ply(f)
+        print('file_name', f)
+        pc.save(f)
 
 
 def create_gif(pc):

gradio_cached_examples/23/log.csv

@@ -0,0 +1,3 @@
+component 0,3D Model GIF,Files,flag,username,timestamp
+/home/ubuntu/projects/point-e/gradio_cached_examples/23/component 0/mesh-7259c79c-b649-4624-b8f8-bbf3b14f83cd953e9b1e5f740a28854cfc36438f0aff107b6445hxmr3f9j.ply,/home/ubuntu/projects/point-e/gradio_cached_examples/23/3D Model GIF/pointcloudcb15136570dba10312c5ed2976c55c6e5c7903f9opvwj32a.mp4,"{'visible': True, 'value': [{'orig_name': 'mesh-7259c79c-b649-4624-b8f8-bbf3b14f83cd.ply', 'name': '/tmp/mesh-7259c79c-b649-4624-b8f8-bbf3b14f83cd953e9b1e5f740a28854cfc36438f0aff107b6445.ply', 'size': 61618, 'data': None, 'is_file': True}], '__type__': 'update'}",,,2023-01-15 14:43:34.639847
+/home/ubuntu/projects/point-e/gradio_cached_examples/23/component 0/mesh-df8501bb-16fa-4466-9c0d-18409527fdd2ad7655a800cfbeee95686246fb97c498a43a20d1k_ba3j63.ply,/home/ubuntu/projects/point-e/gradio_cached_examples/23/3D Model GIF/pointcloudeed5baa5cdb39407318886f10f2fb96294f7394cp5ikcutv.mp4,"{'visible': True, 'value': [{'orig_name': 'mesh-df8501bb-16fa-4466-9c0d-18409527fdd2.ply', 'name': '/tmp/mesh-df8501bb-16fa-4466-9c0d-18409527fdd2ad7655a800cfbeee95686246fb97c498a43a20d1.ply', 'size': 61618, 'data': None, 'is_file': True}], '__type__': 'update'}",,,2023-01-15 14:45:23.412352

pc.py

@@ -0,0 +1,174 @@
+import random
+from dataclasses import dataclass
+from typing import BinaryIO, Dict, List, Optional, Union
+
+import numpy as np
+
+from .ply_util import write_ply
+
+COLORS = frozenset(["R", "G", "B", "A"])
+
+
+def preprocess(data, channel):
+    if channel in COLORS:
+        return np.round(data * 255.0)
+    return data
+
+
+@dataclass
+class PointCloud:
+    """
+    An array of points sampled on a surface. Each point may have zero or more
+    channel attributes.
+
+    :param coords: an [N x 3] array of point coordinates.
+    :param channels: a dict mapping names to [N] arrays of channel values.
+    """
+
+    coords: np.ndarray
+    channels: Dict[str, np.ndarray]
+
+    @classmethod
+    def load(cls, f: Union[str, BinaryIO]) -> "PointCloud":
+        """
+        Load the point cloud from a .npz file.
+        """
+        if isinstance(f, str):
+            with open(f, "rb") as reader:
+                return cls.load(reader)
+        else:
+            obj = np.load(f)
+            keys = list(obj.keys())
+            return PointCloud(
+                coords=obj["coords"],
+                channels={k: obj[k] for k in keys if k != "coords"},
+            )
+
+    def save(self, f: Union[str, BinaryIO]):
+        """
+        Save the point cloud to a .npz file.
+        """
+        if isinstance(f, str):
+            with open(f, "wb") as writer:
+                self.save(writer)
+        else:
+            np.save(f, self.coords)
+
+    def write_ply(self, raw_f: BinaryIO):
+        write_ply(
+            raw_f,
+            coords=self.coords,
+            rgb=(
+                np.stack([self.channels[x] for x in "RGB"], axis=1)
+                if all(x in self.channels for x in "RGB")
+                else None
+            ),
+        )
+
+    def random_sample(self, num_points: int, **subsample_kwargs) -> "PointCloud":
+        """
+        Sample a random subset of this PointCloud.
+
+        :param num_points: maximum number of points to sample.
+        :param subsample_kwargs: arguments to self.subsample().
+        :return: a reduced PointCloud, or self if num_points is not less than
+                 the current number of points.
+        """
+        if len(self.coords) <= num_points:
+            return self
+        indices = np.random.choice(len(self.coords), size=(num_points,), replace=False)
+        return self.subsample(indices, **subsample_kwargs)
+
+    def farthest_point_sample(
+        self, num_points: int, init_idx: Optional[int] = None, **subsample_kwargs
+    ) -> "PointCloud":
+        """
+        Sample a subset of the point cloud that is evenly distributed in space.
+
+        First, a random point is selected. Then each successive point is chosen
+        such that it is furthest from the currently selected points.
+
+        The time complexity of this operation is O(NM), where N is the original
+        number of points and M is the reduced number. Therefore, performance
+        can be improved by randomly subsampling points with random_sample()
+        before running farthest_point_sample().
+
+        :param num_points: maximum number of points to sample.
+        :param init_idx: if specified, the first point to sample.
+        :param subsample_kwargs: arguments to self.subsample().
+        :return: a reduced PointCloud, or self if num_points is not less than
+                 the current number of points.
+        """
+        if len(self.coords) <= num_points:
+            return self
+        init_idx = random.randrange(len(self.coords)) if init_idx is None else init_idx
+        indices = np.zeros([num_points], dtype=np.int64)
+        indices[0] = init_idx
+        sq_norms = np.sum(self.coords**2, axis=-1)
+
+        def compute_dists(idx: int):
+            # Utilize equality: ||A-B||^2 = ||A||^2 + ||B||^2 - 2*(A @ B).
+            return sq_norms + sq_norms[idx] - 2 * (self.coords @ self.coords[idx])
+
+        cur_dists = compute_dists(init_idx)
+        for i in range(1, num_points):
+            idx = np.argmax(cur_dists)
+            indices[i] = idx
+            cur_dists = np.minimum(cur_dists, compute_dists(idx))
+        return self.subsample(indices, **subsample_kwargs)
+
+    def subsample(self, indices: np.ndarray, average_neighbors: bool = False) -> "PointCloud":
+        if not average_neighbors:
+            return PointCloud(
+                coords=self.coords[indices],
+                channels={k: v[indices] for k, v in self.channels.items()},
+            )
+
+        new_coords = self.coords[indices]
+        neighbor_indices = PointCloud(coords=new_coords, channels={}).nearest_points(self.coords)
+
+        # Make sure every point points to itself, which might not
+        # be the case if points are duplicated or there is rounding
+        # error.
+        neighbor_indices[indices] = np.arange(len(indices))
+
+        new_channels = {}
+        for k, v in self.channels.items():
+            v_sum = np.zeros_like(v[: len(indices)])
+            v_count = np.zeros_like(v[: len(indices)])
+            np.add.at(v_sum, neighbor_indices, v)
+            np.add.at(v_count, neighbor_indices, 1)
+            new_channels[k] = v_sum / v_count
+        return PointCloud(coords=new_coords, channels=new_channels)
+
+    def select_channels(self, channel_names: List[str]) -> np.ndarray:
+        data = np.stack([preprocess(self.channels[name], name) for name in channel_names], axis=-1)
+        return data
+
+    def nearest_points(self, points: np.ndarray, batch_size: int = 16384) -> np.ndarray:
+        """
+        For each point in another set of points, compute the point in this
+        pointcloud which is closest.
+
+        :param points: an [N x 3] array of points.
+        :param batch_size: the number of neighbor distances to compute at once.
+                           Smaller values save memory, while larger values may
+                           make the computation faster.
+        :return: an [N] array of indices into self.coords.
+        """
+        norms = np.sum(self.coords**2, axis=-1)
+        all_indices = []
+        for i in range(0, len(points), batch_size):
+            batch = points[i : i + batch_size]
+            dists = norms + np.sum(batch**2, axis=-1)[:, None] - 2 * (batch @ self.coords.T)
+            all_indices.append(np.argmin(dists, axis=-1))
+        return np.concatenate(all_indices, axis=0)
+
+    def combine(self, other: "PointCloud") -> "PointCloud":
+        assert self.channels.keys() == other.channels.keys()
+        return PointCloud(
+            coords=np.concatenate([self.coords, other.coords], axis=0),
+            channels={
+                k: np.concatenate([v, other.channels[k]], axis=0) for k, v in self.channels.items()
+            },
+        )