Setter for sensor_position and sensor_orientation (strawlab#156)

* add setter for PointCloud.sensor_origin

* add setter for PointCloud.sensor_orientation

pcl/eigen.pxd

@@ -58,11 +58,12 @@ cdef extern from "Eigen/Eigen" namespace "Eigen" nogil:
         float& element "operator()"(int row, int col)
     cdef cppclass Vector4f:
         Vector4f() except +
+        Vector4f(float c0, float c1, float c2, float c3) except + 
         float *data()
         float& element "operator()"(int row, int col)
     cdef cppclass Vector3f:
         Vector3f() except +
-        Vector3f(double c0, double c1, double c2) except + 
+        Vector3f(float c0, float c1, float c2) except + 
         float *data()
         float& element "operator()"(int row, int col)
     cdef cppclass Vector3i:
@@ -75,6 +76,8 @@ cdef extern from "Eigen/Eigen" namespace "Eigen" nogil:
         double coeff(int row, int col)
         double& element "operator()"(int row, int col)
     cdef cppclass Quaternionf:
+        Quaternionf()
+        Quaternionf(float, float, float, float)
         float w()
         float x()
         float y()

pcl/pxi/PointCloud_FPFHSignature33.pxi

@@ -111,11 +111,25 @@ cdef class PointCloud_FPFHSignature33:
             return np.array([data[0], data[1], data[2], data[3]],
                             dtype=np.float32)
 
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_origin):
+            self.thisptr().sensor_origin_ = cpp.Vector4f(
+                    new_origin[0],
+                    new_origin[1],
+                    new_origin[2],
+                    0.0)
+
     property sensor_orientation:
         def __get__(self):
             # NumPy doesn't have a quaternion type, so we return a 4-vector.
             cdef cpp.Quaternionf o = self.thisptr().sensor_orientation_
-            return np.array([o.w(), o.x(), o.y(), o.z()])
+            return np.array([o.w(), o.x(), o.y(), o.z()], dtype=np.float32)
+
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_orient):
+            self.thisptr().sensor_orientation_ = cpp.Quaternionf(
+                    new_orient[0],
+                    new_orient[1],
+                    new_orient[2],
+                    new_orient[3])
 
     @cython.boundscheck(False)
     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):

pcl/pxi/PointCloud_PCLPointCloud2.pxi

@@ -140,11 +140,25 @@ cdef class PCLPointCloud2:
             return np.array([data[0], data[1], data[2], data[3]],
                             dtype=np.float32)
 
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_origin):
+            self.thisptr().sensor_origin_ = cpp.Vector4f(
+                    new_origin[0],
+                    new_origin[1],
+                    new_origin[2],
+                    0.0)
+
     property sensor_orientation:
         def __get__(self):
             # NumPy doesn't have a quaternion type, so we return a 4-vector.
             cdef cpp.Quaternionf o = self.thisptr().sensor_orientation_
-            return np.array([o.w(), o.x(), o.y(), o.z()])
+            return np.array([o.w(), o.x(), o.y(), o.z()], dtype=np.float32)
+
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_orient):
+            self.thisptr().sensor_orientation_ = cpp.Quaternionf(
+                    new_orient[0],
+                    new_orient[1],
+                    new_orient[2],
+                    new_orient[3])
 
     @cython.boundscheck(False)
     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):

pcl/pxi/PointCloud_PCLPointCloud2_180.pxi

@@ -140,11 +140,25 @@ cdef class PCLPointCloud2:
             return np.array([data[0], data[1], data[2], data[3]],
                             dtype=np.float32)
 
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_origin):
+            self.thisptr().sensor_origin_ = cpp.Vector4f(
+                    new_origin[0],
+                    new_origin[1],
+                    new_origin[2],
+                    0.0)
+
     property sensor_orientation:
         def __get__(self):
             # NumPy doesn't have a quaternion type, so we return a 4-vector.
             cdef cpp.Quaternionf o = self.thisptr().sensor_orientation_
-            return np.array([o.w(), o.x(), o.y(), o.z()])
+            return np.array([o.w(), o.x(), o.y(), o.z()], dtype=np.float32)
+
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_orient):
+            self.thisptr().sensor_orientation_ = cpp.Quaternionf(
+                    new_orient[0],
+                    new_orient[1],
+                    new_orient[2],
+                    new_orient[3])
 
     @cython.boundscheck(False)
     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):

pcl/pxi/PointCloud_PointCloud2.pxi

@@ -140,11 +140,25 @@ cdef class PointCloud2:
             return np.array([data[0], data[1], data[2], data[3]],
                             dtype=np.float32)
 
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_origin):
+            self.thisptr().sensor_origin_ = cpp.Vector4f(
+                    new_origin[0],
+                    new_origin[1],
+                    new_origin[2],
+                    0.0)
+
     property sensor_orientation:
         def __get__(self):
             # NumPy doesn't have a quaternion type, so we return a 4-vector.
             cdef cpp.Quaternionf o = self.thisptr().sensor_orientation_
-            return np.array([o.w(), o.x(), o.y(), o.z()])
+            return np.array([o.w(), o.x(), o.y(), o.z()], dtype=np.float32)
+
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_orient):
+            self.thisptr().sensor_orientation_ = cpp.Quaternionf(
+                    new_orient[0],
+                    new_orient[1],
+                    new_orient[2],
+                    new_orient[3])
 
     @cython.boundscheck(False)
     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):

pcl/pxi/PointCloud_PointXYZ.pxi

@@ -138,11 +138,25 @@ cdef class PointCloud:
             return np.array([data[0], data[1], data[2], data[3]],
                             dtype=np.float32)
 
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_origin):
+            self.thisptr().sensor_origin_ = cpp.Vector4f(
+                    new_origin[0],
+                    new_origin[1],
+                    new_origin[2],
+                    0.0)
+
     property sensor_orientation:
         def __get__(self):
             # NumPy doesn't have a quaternion type, so we return a 4-vector.
             cdef cpp.Quaternionf o = self.thisptr().sensor_orientation_
-            return np.array([o.w(), o.x(), o.y(), o.z()])
+            return np.array([o.w(), o.x(), o.y(), o.z()], dtype=np.float32)
+
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_orient):
+            self.thisptr().sensor_orientation_ = cpp.Quaternionf(
+                    new_orient[0],
+                    new_orient[1],
+                    new_orient[2],
+                    new_orient[3])
 
     @cython.boundscheck(False)
     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):

pcl/pxi/PointCloud_PointXYZI.pxi

@@ -134,11 +134,25 @@ cdef class PointCloud_PointXYZI:
             return np.array([data[0], data[1], data[2], data[3]],
                             dtype=np.float32)
 
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_origin):
+            self.thisptr().sensor_origin_ = cpp.Vector4f(
+                    new_origin[0],
+                    new_origin[1],
+                    new_origin[2],
+                    0.0)
+
     property sensor_orientation:
         def __get__(self):
             # NumPy doesn't have a quaternion type, so we return a 4-vector.
             cdef cpp.Quaternionf o = self.thisptr().sensor_orientation_
-            return np.array([o.w(), o.x(), o.y(), o.z()])
+            return np.array([o.w(), o.x(), o.y(), o.z()], dtype=np.float32)
+
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_orient):
+            self.thisptr().sensor_orientation_ = cpp.Quaternionf(
+                    new_orient[0],
+                    new_orient[1],
+                    new_orient[2],
+                    new_orient[3])
 
     @cython.boundscheck(False)
     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):

pcl/pxi/PointCloud_PointXYZI_172.pxi

@@ -130,11 +130,25 @@ cdef class PointCloud_PointXYZI:
             return np.array([data[0], data[1], data[2], data[3]],
                             dtype=np.float32)
 
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_origin):
+            self.thisptr().sensor_origin_ = cpp.Vector4f(
+                    new_origin[0],
+                    new_origin[1],
+                    new_origin[2],
+                    0.0)
+
     property sensor_orientation:
         def __get__(self):
             # NumPy doesn't have a quaternion type, so we return a 4-vector.
             cdef cpp.Quaternionf o = self.thisptr().sensor_orientation_
-            return np.array([o.w(), o.x(), o.y(), o.z()])
+            return np.array([o.w(), o.x(), o.y(), o.z()], dtype=np.float32)
+
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_orient):
+            self.thisptr().sensor_orientation_ = cpp.Quaternionf(
+                    new_orient[0],
+                    new_orient[1],
+                    new_orient[2],
+                    new_orient[3])
 
     @cython.boundscheck(False)
     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):

pcl/pxi/PointCloud_PointXYZI_180.pxi

@@ -130,11 +130,25 @@ cdef class PointCloud_PointXYZI:
             return np.array([data[0], data[1], data[2], data[3]],
                             dtype=np.float32)
 
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_origin):
+            self.thisptr().sensor_origin_ = cpp.Vector4f(
+                    new_origin[0],
+                    new_origin[1],
+                    new_origin[2],
+                    0.0)
+
     property sensor_orientation:
         def __get__(self):
             # NumPy doesn't have a quaternion type, so we return a 4-vector.
             cdef cpp.Quaternionf o = self.thisptr().sensor_orientation_
-            return np.array([o.w(), o.x(), o.y(), o.z()])
+            return np.array([o.w(), o.x(), o.y(), o.z()], dtype=np.float32)
+
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_orient):
+            self.thisptr().sensor_orientation_ = cpp.Quaternionf(
+                    new_orient[0],
+                    new_orient[1],
+                    new_orient[2],
+                    new_orient[3])
 
     @cython.boundscheck(False)
     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):

pcl/pxi/PointCloud_PointXYZRGB.pxi

@@ -127,11 +127,25 @@ cdef class PointCloud_PointXYZRGB:
             return np.array([data[0], data[1], data[2], data[3]],
                             dtype=np.float32)
 
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_origin):
+            self.thisptr().sensor_origin_ = cpp.Vector4f(
+                    new_origin[0],
+                    new_origin[1],
+                    new_origin[2],
+                    0.0)
+
     property sensor_orientation:
         def __get__(self):
             # NumPy doesn't have a quaternion type, so we return a 4-vector.
             cdef cpp.Quaternionf o = self.thisptr().sensor_orientation_
-            return np.array([o.w(), o.x(), o.y(), o.z()])
+            return np.array([o.w(), o.x(), o.y(), o.z()], dtype=np.float32)
+
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_orient):
+            self.thisptr().sensor_orientation_ = cpp.Quaternionf(
+                    new_orient[0],
+                    new_orient[1],
+                    new_orient[2],
+                    new_orient[3])
 
     @cython.boundscheck(False)
     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):

pcl/pxi/PointCloud_PointXYZRGBA.pxi

@@ -127,11 +127,25 @@ cdef class PointCloud_PointXYZRGBA:
             return np.array([data[0], data[1], data[2], data[3]],
                             dtype=np.float32)
 
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_origin):
+            self.thisptr().sensor_origin_ = cpp.Vector4f(
+                    new_origin[0],
+                    new_origin[1],
+                    new_origin[2],
+                    0.0)
+
     property sensor_orientation:
         def __get__(self):
             # NumPy doesn't have a quaternion type, so we return a 4-vector.
             cdef cpp.Quaternionf o = self.thisptr().sensor_orientation_
-            return np.array([o.w(), o.x(), o.y(), o.z()])
+            return np.array([o.w(), o.x(), o.y(), o.z()], dtype=np.float32)
+
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_orient):
+            self.thisptr().sensor_orientation_ = cpp.Quaternionf(
+                    new_orient[0],
+                    new_orient[1],
+                    new_orient[2],
+                    new_orient[3])
 
     @cython.boundscheck(False)
     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):

pcl/pxi/PointCloud_PointXYZRGBA_172.pxi

@@ -129,11 +129,25 @@ cdef class PointCloud_PointXYZRGBA:
             return np.array([data[0], data[1], data[2], data[3]],
                             dtype=np.float32)
 
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_origin):
+            self.thisptr().sensor_origin_ = cpp.Vector4f(
+                    new_origin[0],
+                    new_origin[1],
+                    new_origin[2],
+                    0.0)
+
     property sensor_orientation:
         def __get__(self):
             # NumPy doesn't have a quaternion type, so we return a 4-vector.
             cdef cpp.Quaternionf o = self.thisptr().sensor_orientation_
-            return np.array([o.w(), o.x(), o.y(), o.z()])
+            return np.array([o.w(), o.x(), o.y(), o.z()], dtype=np.float32)
+
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_orient):
+            self.thisptr().sensor_orientation_ = cpp.Quaternionf(
+                    new_orient[0],
+                    new_orient[1],
+                    new_orient[2],
+                    new_orient[3])
 
     @cython.boundscheck(False)
     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):

pcl/pxi/PointCloud_PointXYZRGBA_180.pxi

@@ -129,11 +129,25 @@ cdef class PointCloud_PointXYZRGBA:
             return np.array([data[0], data[1], data[2], data[3]],
                             dtype=np.float32)
 
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_origin):
+            self.thisptr().sensor_origin_ = cpp.Vector4f(
+                    new_origin[0],
+                    new_origin[1],
+                    new_origin[2],
+                    0.0)
+
     property sensor_orientation:
         def __get__(self):
             # NumPy doesn't have a quaternion type, so we return a 4-vector.
             cdef cpp.Quaternionf o = self.thisptr().sensor_orientation_
-            return np.array([o.w(), o.x(), o.y(), o.z()])
+            return np.array([o.w(), o.x(), o.y(), o.z()], dtype=np.float32)
+
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_orient):
+            self.thisptr().sensor_orientation_ = cpp.Quaternionf(
+                    new_orient[0],
+                    new_orient[1],
+                    new_orient[2],
+                    new_orient[3])
 
     @cython.boundscheck(False)
     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):

pcl/pxi/PointCloud_PointXYZRGB_172.pxi

@@ -129,11 +129,25 @@ cdef class PointCloud_PointXYZRGB:
             return np.array([data[0], data[1], data[2], data[3]],
                             dtype=np.float32)
 
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_origin):
+            self.thisptr().sensor_origin_ = cpp.Vector4f(
+                    new_origin[0],
+                    new_origin[1],
+                    new_origin[2],
+                    0.0)
+
     property sensor_orientation:
         def __get__(self):
             # NumPy doesn't have a quaternion type, so we return a 4-vector.
             cdef cpp.Quaternionf o = self.thisptr().sensor_orientation_
-            return np.array([o.w(), o.x(), o.y(), o.z()])
+            return np.array([o.w(), o.x(), o.y(), o.z()], dtype=np.float32)
+
+        def __set__(self, cnp.ndarray[cnp.float32_t, ndim=1] new_orient):
+            self.thisptr().sensor_orientation_ = cpp.Quaternionf(
+                    new_orient[0],
+                    new_orient[1],
+                    new_orient[2],
+                    new_orient[3])
 
     @cython.boundscheck(False)
     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):