packing fix and docstrings

Author: mikedh

.travis.yml

@@ -79,12 +79,14 @@ script:
 - python -c "import trimesh"
 - pytest tests/test_inertia.py
 
-# install most deps here
+# shapely/rtree are easiest to get from conda
 - conda install scikit-image rtree shapely
-# eat exit codes for these two packages
+
 # pyembree and python-fcl not available everywhere
-- conda install pyembree || true
-- pip install python-fcl || true
+- if [[ "$TRAVIS_PYTHON_VERSION" == "3.6" ]]; then conda install pyembree; fi;
+- if [[ "$TRAVIS_PYTHON_VERSION" == "3.6" ]]; then pip install python-fcl; fi;
+
+# install most deps here
 - pip install .[easy]
 - pip install triangle xxhash
 
@@ -94,7 +96,7 @@ script:
 # downgrade networkx from 2.x to 1.x to make sure our
 # graph operations work on both versions of their API
 - pip install -Iv networkx==1.11
-- python -c "import networkx; print(networkx.__version__)"
+- python -c "import networkx; print('::NX_VERSION::', networkx.__version__)"
 - pytest tests/test_graph.py tests/test_scene.py
 
 # make sure examples still work

tests/generic.py

@@ -85,6 +85,7 @@
 
 io_wrap = trimesh.util.wrap_as_stream
 
+
 def _load_data():
     data = {}
     for file_name in os.listdir(dir_data):

tests/test_packing.py

@@ -17,8 +17,13 @@ def test_obb(self):
     def test_paths(self):
         from trimesh.path import packing
         paths = [g.trimesh.load_path(i) for i in self.nestable]
-        r = packing.pack_paths(paths)
 
+        r, inserted = packing.pack_paths(paths)
+
+        # number of paths inserted
+        count = len(g.np.unique(inserted))
+        assert count == len(paths)
+        assert count == len(r.split())
 
 if __name__ == '__main__':
     g.trimesh.util.attach_to_log()

tests/test_paths.py

@@ -57,17 +57,16 @@ def test_discrete(self):
                     g.log.error('On file %s First and last vertex distance %f',
                                 d.metadata['file_name'],
                                 circuit_dist)
-                self.assertTrue(circuit_test)
+                assert circuit_test
 
                 is_ccw = g.trimesh.path.util.is_ccw(verts)
                 if not is_ccw:
                     g.log.error('discrete %s not ccw!',
                                 d.metadata['file_name'])
-                # self.assertTrue(is_ccw)
 
             for i in range(len(d.paths)):
-                self.assertTrue(d.polygons_closed[i].is_valid)
-                self.assertTrue(d.polygons_closed[i].area > g.tol_path.zero)
+                assert d.polygons_closed[i].is_valid
+                assert d.polygons_closed[i].area > g.tol_path.zero
             export_dict = d.export(file_type='dict')
             to_dict = d.to_dict()
             assert isinstance(to_dict, dict)
@@ -86,6 +85,15 @@ def test_discrete(self):
             if len(d.root) == 1:
                 d.apply_obb()
 
+            # store the X values of bounds
+            ori = d.bounds.copy()
+            # apply a translation
+            d.apply_translation([10, 0])
+            # X should have translated by 10.0
+            assert g.np.allclose(d.bounds[:, 0] - 10, ori[:, 0])
+            # Y should not have moved
+            assert g.np.allclose(d.bounds[:, 1], ori[:, 1])
+
             if len(d.vertices) < 150:
                 g.log.info('Checking medial axis on %s',
                            d.metadata['file_name'])
@@ -99,22 +107,22 @@ def test_discrete(self):
 
     def test_poly(self):
         p = g.get_mesh('2D/LM2.dxf')
-        self.assertTrue(p.is_closed)
-        self.assertTrue(any(len(i.points) > 2 for i in p.entities if
-                            g.trimesh.util.is_instance_named(i, 'Line')))
+        assert p.is_closed
+        assert any(len(i.points) > 2 for i in p.entities if
+                   g.trimesh.util.is_instance_named(i, 'Line'))
 
         assert len(p.layers) == len(p.entities)
         assert len(g.np.unique(p.layers)) > 1
 
         p.explode()
-        self.assertTrue(all(len(i.points) == 2 for i in p.entities if
-                            g.trimesh.util.is_instance_named(i, 'Line')))
-        self.assertTrue(p.is_closed)
+        assert all(len(i.points) == 2 for i in p.entities if
+                   g.trimesh.util.is_instance_named(i, 'Line'))
+        assert p.is_closed
         p.entities = p.entities[:-1]
         self.assertFalse(p.is_closed)
 
         p.fill_gaps()
-        self.assertTrue(p.is_closed)
+        assert p.is_closed
 
     def test_edges(self):
         """
@@ -187,8 +195,8 @@ def test_sample(self):
         # test sampling with multiple bodies
         for i in range(3):
             assert g.np.isclose(path.area, p.area * (i + 1))
-            path = path + \
-                g.trimesh.load_path(g.Point([(i + 2) * 2, 0]).buffer(1.0))
+            path = path + g.trimesh.load_path(
+                g.Point([(i + 2) * 2, 0]).buffer(1.0))
             s = path.sample(count=count)
             assert s.shape[1] == 2
 
@@ -207,9 +215,8 @@ def test_center(self):
                           center_info['normal'],
                           center_info['span'])
 
-        self.assertTrue(abs(R - res_radius) < g.tol_path.zero)
-        self.assertTrue(g.trimesh.util.euclidean(
-            C, res_center) < g.tol_path.zero)
+        assert abs(R - res_radius) < g.tol_path.zero
+        assert g.trimesh.util.euclidean(C, res_center) < g.tol_path.zero
 
     def test_center_random(self):
 

trimesh/path/entities.py

@@ -94,6 +94,11 @@ def end_points(self):
     def is_valid(self):
         """
         Is the current entity valid.
+
+        Returns
+        -----------
+        valid : bool
+          Is the current entity well formed
         """
         return True
 
@@ -183,25 +188,36 @@ def discrete(self, vertices, scale=1.0):
 
         Parameters
         ------------
-        vertices: (n, dimension) float, points in space
-        scale:    float, size of overall scene for numerical comparisons
+        vertices: (n, dimension) float
+          Points in space
+        scale : float
+          Size of overall scene for numerical comparisons
 
         Returns
         -------------
-        discrete: (m, dimension) float, linear path in space
+        discrete: (m, dimension) float
+          Path in space composed of line segments
         """
         discrete = self._orient(vertices[self.points])
         return discrete
 
     @property
     def is_valid(self):
+        """
+        Is the current entity valid.
+
+        Returns
+        -----------
+        valid : bool
+          Is the current entity well formed
+        """
         valid = np.any((self.points - self.points[0]) != 0)
         return valid
 
     def explode(self):
         """
-        If the current Line entity consists of multiple lines, break it
-        up into n Line entities.
+        If the current Line entity consists of multiple line
+        break it up into n Line entities.
 
         Returns
         ----------
@@ -223,16 +239,38 @@ def closed(self):
 
         Returns
         ----------
-        closed: bool, if true arc will be a closed circle in space
+        closed : bool
+          If set True, Arc will be a closed circle
         """
         if hasattr(self, '_closed'):
             return self._closed
         return False
 
     @closed.setter
     def closed(self, value):
+        """
+        Set the Arc to be closed or not, without
+        changing the control points
+
+        Parameters
+        ------------
+        value : bool
+          Should this Arc be a closed circle or not
+        """
         self._closed = bool(value)
 
+    @property
+    def is_valid(self):
+        """
+        Is the current Arc entity valid.
+
+        Returns
+        -----------
+        valid : bool
+          Does the current Arc have exactly 3 control points
+        """
+        return len(np.unique(self.points)) == 3
+
     def _bytes(self):
         hashable = (self.__class__.__name__.encode('utf-8') +
                     bytes(bool(self.closed)) +
@@ -307,7 +345,9 @@ def bounds(self, vertices):
 
 
 class Curve(Entity):
-
+    """
+    The parent class for all wild curves in space.
+    """
     @property
     def nodes(self):
         return [[self.points[0],
@@ -317,15 +357,38 @@ def nodes(self):
 
 
 class Bezier(Curve):
+    """
+    An open or closed Bezier curve
+    """
 
     def discrete(self, vertices, scale=1.0, count=None):
+        """
+        Discretize the Bezier curve.
+
+        Parameters
+        -------------
+        vertices : (n, 2) or (n, 3) float
+          Points in space
+        scale : float
+          Scale of overall drawings (for precision)
+        count : int
+          Number of segments to reurn
+
+        Returns
+        -------------
+        discrete : (m, 2) or (m, 3) float
+          Curve as line segments
+        """
         discrete = discretize_bezier(vertices[self.points],
                                      count=count,
                                      scale=scale)
         return self._orient(discrete)
 
 
 class BSpline(Curve):
+    """
+    An open or closed B- Spline.
+    """
 
     def __init__(self, points,
                  knots,
@@ -338,6 +401,23 @@ def __init__(self, points,
         self.kwargs = kwargs
 
     def discrete(self, vertices, count=None, scale=1.0):
+        """
+        Discretize the B-Spline curve.
+
+        Parameters
+        -------------
+        vertices : (n, 2) or (n, 3) float
+          Points in space
+        scale : float
+          Scale of overall drawings (for precision)
+        count : int
+          Number of segments to reurn
+
+        Returns
+        -------------
+        discrete : (m, 2) or (m, 3) float
+          Curve as line segments
+        """
         discrete = discretize_bspline(
             control=vertices[self.points],
             knots=self.knots,