Add test for sinuosity and travelled dist

navipy/trajectories/__init__.py

@@ -102,7 +102,7 @@ def _invmarkerstransform(index_i, trajectory,
 class Trajectory(pd.DataFrame):
     def __init__(self, rotconv='zyx', indeces=np.arange(1)):
         columns = self.__build_columns(rotconv)
-        super().__init__(index=indeces, columns=columns)
+        super().__init__(index=indeces, columns=columns, dtype=np.float)
         self.__rotconv = rotconv
         self.sampling_rate = 0
 
@@ -678,12 +678,12 @@ class Trajectory(pd.DataFrame):
         # We remove nans between section
         # and then calculate the velocity
         # it is equivalent to interpolate between non-nan blocks
-        subtraj = self.location.dropna().reset_index().drop('index',
-                                                            axis=1, level=0)
+        subtraj = self.location.dropna().reset_index().drop('index', axis=1)
         if subtraj.dropna().shape[0] < 2:
             print('Trajectory has less than 2 non nans points')
             return np.nan
-        velocity = subtraj.diff()  # only location is of relevance
+        # only location is of relevance
+        velocity = subtraj.astype(float).diff()
         speed = np.sqrt(velocity.x**2 + velocity.y**2 + velocity.z**2)
         travel_dist = np.sum(speed)
         return travel_dist

navipy/trajectories/test_trajectory.py

@@ -54,38 +54,39 @@ class TestTrajectoryTransform(unittest.TestCase):
         pass
 
     def test_traveldist(self):
-        indeces = np.linspace(0, 2*np.pi, 1000)
+        indeces = np.linspace(0, 2*np.pi, 2000)
         radius = 5
         mytraj = Trajectory(indeces=indeces, rotconv='zyx')
-        mytraj.x = indeces
-        mytraj.y = radius*np.cos(indeces)
+        mytraj.x = radius*np.cos(indeces)
+        mytraj.y = radius*np.sin(indeces)
         mytraj.z = 0
-        # The length of a cos from 0 to 2pi
+        # The length of function above
         # is equal to perimeter of the circle
         # 2*pi*r
         travel_dist_theo = 2*np.pi*radius
         travel_dist = mytraj.traveled_distance()
-        np.testing.assert_almost_equal(travel_dist, travel_dist_theo)
+        np.testing.assert_almost_equal(
+            travel_dist, travel_dist_theo, decimal=4)
         # Test with nans
-        mytraj.loc[[15, 50, 90], :] = np.nan
+        mytraj.iloc[[15, 50, 90], :] = np.nan
         travel_dist = mytraj.traveled_distance()
-        np.testing.assert_almost_equal(travel_dist, travel_dist_theo)
+        np.testing.assert_almost_equal(
+            travel_dist, travel_dist_theo, decimal=4)
 
     def test_sinuosity(self):
-        indeces = np.linspace(0, 2*np.pi, 1000)
+        indeces = np.linspace(0, np.pi, 1000)
         radius = 5
         mytraj = Trajectory(indeces=indeces, rotconv='zyx')
-        mytraj.x = indeces
-        mytraj.y = radius*np.cos(indeces)
+        mytraj.x = radius*np.cos(indeces)
+        mytraj.y = radius*np.sin(indeces)
         mytraj.z = 0
-        # The length of a cos from 0 to 2pi
-        # is equal to perimeter of the circle
-        # 2*pi*r
-        # the sinuosity will be equal to the radius
-        # because dist from start to end is 2*pi
-        sinuosity_theo = radius
+        # The length  of function above
+        # is equal to half the perimeter of the circle
+        # pi*r
+        # the sinuosity will be equal to:
+        sinuosity_theo = np.pi*radius/(2*radius)
         sinuosity = mytraj.sinuosity()
-        np.testing.assert_almost_equal(sinuosity, sinuosity_theo)
+        np.testing.assert_almost_equal(sinuosity, sinuosity_theo, decimal=4)
 
 
 if __name__ == '__main__':