simplify fix and points test

Author: mikedh

tests/test_points.py

@@ -7,9 +7,9 @@
 class PointsTest(g.unittest.TestCase):
 
     def test_pointcloud(self):
-        '''
-        Test pointcloud object
-        '''
+        """
+        Test PointCloud object
+        """
         shape = (100, 3)
         # random points
         points = g.np.random.random(shape)
@@ -22,16 +22,20 @@ def test_pointcloud(self):
         # create a pointcloud object
         cloud = g.trimesh.points.PointCloud(points)
 
-        # set some random colors
-        cloud.colors = g.np.random.random((shape[0], 4))
+        initial_md5 = cloud.md5()
 
         assert cloud.convex_hull.volume > 0.0
 
         # check shapes of data
         assert cloud.vertices.shape == shape
+        assert cloud.shape == shape
         assert cloud.extents.shape == (3,)
         assert cloud.bounds.shape == (2, 3)
 
+        assert cloud.md5() == initial_md5
+
+        # set some random colors
+        cloud.colors = g.np.random.random((shape[0], 4))
         # remove the duplicates we created
         cloud.merge_vertices()
 
@@ -41,6 +45,11 @@ def test_pointcloud(self):
         # make sure vertices and colors are new shape
         assert cloud.vertices.shape == new_shape
         assert len(cloud.colors) == new_shape[0]
+        assert cloud.md5() != initial_md5
+
+        # check getitem and setitem
+        cloud[0] = [10, 10, 10]
+        assert g.np.allclose(cloud[0], [10, 10, 10])
 
     def test_vertex_only(self):
         """
@@ -79,6 +88,30 @@ def test_plane(self):
             # sign of normal is arbitrary on fit so check both
             assert g.np.allclose(truth, N) or g.np.allclose(truth, -N)
 
+    def test_kmeans(self,
+                    cluster_count=5,
+                    points_per_cluster=100):
+        """
+        Test K-means clustering
+        """
+        clustered = []
+        for i in range(cluster_count):
+            clustered.append(
+                g.np.random.random((points_per_cluster, 3)) + (i * 10.0))
+        clustered = g.np.vstack(clustered)
+
+        # run k- means clustering on our nicely separated data
+        centroids, klabel = g.trimesh.points.k_means(points=clustered,
+                                                     k=cluster_count)
+
+        # reshape to make sure all groups have the same index
+        variance = klabel.reshape(
+            (cluster_count, points_per_cluster)).ptp(
+            axis=1)
+
+        assert len(centroids) == cluster_count
+        assert (variance == 0).all()
+
 
 if __name__ == '__main__':
     g.trimesh.util.attach_to_log()

tests/test_simplify.py

@@ -68,6 +68,20 @@ def test_simplify(self):
                 self.polygon_simplify(polygon=polygon,
                                       arc_count=arc_count)
 
+    def test_spline(self):
+        """
+        Test basic spline simplification of Path2D objects
+        """
+        scene = g.get_mesh('cycloidal.3DXML')
+        m = scene.geometry['disc_cam_A']
+
+        path_3D = m.outline(m.facets[m.facets_area.argmax()])
+        path_2D, to_3D = path_3D.to_planar()
+
+        simple = g.trimesh.path.simplify.simplify_spline(path_2D,
+                                                         smooth=.01,
+                                                         verbose=True)
+        assert g.np.isclose(path_2D.area, simple.area, rtol=.01)
 
 if __name__ == '__main__':
     g.trimesh.util.attach_to_log()

trimesh/path/simplify.py

@@ -232,7 +232,7 @@ def resample_spline(points, smooth=.001, count=None, degree=3):
     return resampled
 
 
-def points_to_spline_entity(points, smooth=.0005, count=None):
+def points_to_spline_entity(points, smooth=None, count=None):
     """
     Create a spline entity from a curve in space
 
@@ -251,7 +251,10 @@ def points_to_spline_entity(points, smooth=.0005, count=None):
     from scipy.interpolate import splprep
     if count is None:
         count = len(points)
-    points = np.asanyarray(points)
+    if smooth is None:
+        smooth = 0.002
+
+    points = np.asanyarray(points, dtype=np.float64)
     closed = np.linalg.norm(points[0] - points[-1]) < tol.merge
 
     knots, control, degree = splprep(points.T, s=smooth)[0]
@@ -270,25 +273,6 @@ def points_to_spline_entity(points, smooth=.0005, count=None):
     return entity, control
 
 
-def three_point(indices):
-    """
-    Given a long list of ordered indices,
-    return the first, middle and last.
-
-    Parameters
-    -----------
-    indices: (n,) array
-
-    Returns
-    ----------
-    three: (3,) array
-    """
-    three = [indices[0],
-             indices[int(len(indices) / 2)],
-             indices[-1]]
-    return np.asanyarray(three)
-
-
 def simplify_basic(drawing, process=False, **kwargs):
     """
     Merge colinear segments and fit circles.
@@ -367,51 +351,51 @@ def simplify_basic(drawing, process=False, **kwargs):
     return simplified
 
 
-def simplify_spline(path, smooth, path_indexes=None):
+def simplify_spline(path, smooth=None, verbose=False):
     """
-    Replace discrete curves with b-spline curves, and
+    Replace discrete curves with b-spline or Arc and
     return the result as a new Path2D object.
 
     Parameters
     ------------
-    path:         Path2D object
-    smooth:       float, amount to smooth
-    path_indexes: (n,) int, indexes of path.paths to simplify
+    path : trimesh.path.Path2D
+      Input geometry
+    smooth : float
+      Distance to smooth
 
     Returns
     ------------
-    simplified: Path2D object, with specified entities replaced
+    simplified : Path2D
+      Consists of Arc and BSpline entities
     """
-    # if we aren't simplifying specific indexes
-    # simplify all indexes in the path object
-    if path_indexes is None:
-        path_indexes = np.arange(len(path.paths))
 
-    entities_keep = np.ones(len(path.entities),
-                            dtype=np.bool)
     new_vertices = []
     new_entities = []
+    scale = path.scale
+
+    for discrete in path.discrete:
+        circle = is_circle(discrete,
+                           scale=scale,
+                           verbose=verbose)
+        if circle is not None:
+            # the points are circular enough for our high standards
+            # so replace them with a closed Arc entity
+            new_entities.append(entities.Arc(points=np.arange(3) +
+                                             len(new_vertices),
+                                             closed=True))
+            new_vertices.extend(circle)
+            continue
 
-    for i in path_indexes:
         # entities for this path
-        entity, vertices = points_to_spline_entity(path.discrete[i])
+        entity, vertices = points_to_spline_entity(discrete, smooth=smooth)
         # reindex returned control points
-        entity.points += len(path.vertices) + len(new_vertices)
+        entity.points += len(new_vertices)
         # save entity and vertices
-        new_vertices.append(vertices)
+        new_vertices.extend(vertices)
         new_entities.append(entity)
-        # we don't need any of the entities from the
-        # path we just consumed and replaced
-        entities_keep[path.paths[i]] = False
-
-    # flatten entities and vertices
-    entities = np.append(path.entities[entities_keep],
-                         new_entities)
-    vertices = np.vstack((path.vertices,
-                          np.vstack(new_vertices)))
 
     # create the Path2D object for the result
-    simplified = type(path)(entities=entities,
-                            vertices=vertices)
+    simplified = type(path)(entities=new_entities,
+                            vertices=new_vertices)
 
     return simplified

trimesh/points.py

@@ -187,24 +187,6 @@ def remove_close(points, radius):
     return points[unique], unique
 
 
-def remove_close_set(points_fixed, points_reduce, radius):
-    """
-    Given two sets of points and a radius, return a set of points
-    that is the subset of points_reduce where no point is within
-    radius of any point in points_fixed
-    """
-    from scipy.spatial import cKDTree as KDTree
-
-    tree_fixed = KDTree(points_fixed)
-    tree_reduce = KDTree(points_reduce)
-    reduce_duplicates = tree_fixed.query_ball_tree(tree_reduce, r=radius)
-    reduce_duplicates = np.unique(np.hstack(reduce_duplicates).astype(int))
-    reduce_mask = np.ones(len(points_reduce), dtype=np.bool)
-    reduce_mask[reduce_duplicates] = False
-    points_clean = points_reduce[reduce_mask]
-    return points_clean
-
-
 def k_means(points, k, **kwargs):
     """
     Find k centroids that attempt to minimize the k- means problem:
@@ -229,13 +211,16 @@ def k_means(points, k, **kwargs):
     from scipy.cluster.vq import kmeans
     from scipy.spatial import cKDTree
 
-    points = np.asanyarray(points)
+    points = np.asanyarray(points, dtype=np.float64)
     points_std = points.std(axis=0)
     whitened = points / points_std
     centroids_whitened, distortion = kmeans(whitened, k, **kwargs)
     centroids = centroids_whitened * points_std
+
+    # find which centroid each point is closest to
     tree = cKDTree(centroids)
     labels = tree.query(points, k=1)[1]
+
     return centroids, labels
 
 
@@ -297,6 +282,7 @@ def __setitem__(self, *args, **kwargs):
     def __getitem__(self, *args, **kwargs):
         return self.vertices.__getitem__(*args, **kwargs)
 
+    @property
     def shape(self):
         """
         Get the shape of the pointcloud

trimesh/version.py

@@ -1 +1 @@
-__version__ = '2.33.23'
+__version__ = '2.33.24'